diff --git a/tracer/build/_build/UpdateVendors/VendoredDependency.cs b/tracer/build/_build/UpdateVendors/VendoredDependency.cs index 5e79cfc28..b07fe3c4e 100644 --- a/tracer/build/_build/UpdateVendors/VendoredDependency.cs +++ b/tracer/build/_build/UpdateVendors/VendoredDependency.cs @@ -46,9 +46,9 @@ static VendoredDependency() Add( libraryName: "MessagePack", - version: "1.9.3", - downloadUrl: "https://github.com/neuecc/MessagePack-CSharp/archive/v1.9.3.zip", - pathToSrc: new[] { "MessagePack-CSharp-1.9.3", "src", "MessagePack" }, + version: "1.9.11", + downloadUrl: "https://github.com/neuecc/MessagePack-CSharp/archive/refs/tags/v1.9.11.zip", + pathToSrc: new[] { "MessagePack-CSharp-1.9.11", "src", "MessagePack" }, transform: filePath => RewriteCsFileWithStandardTransform(filePath, originalNamespace: "MessagePack")); Add( @@ -223,6 +223,42 @@ private bool TryGetValue(string key, [NotNullWhen(true)]out JsonProperty? item) builder.Replace("\"ProtoBuf.ProtoIgnoreAttribute\"", "\"Datadog.Trace.Vendors.ProtoBuf.ProtoIgnoreAttribute\""); builder.Replace("\"ProtoBuf.ProtoMemberAttribute\"", "\"Datadog.Trace.Vendors.ProtoBuf.ProtoMemberAttribute\""); } + // Special MessagePack processing + if (originalNamespace.StartsWith("MessagePack")) + { + var fileName = Path.GetFileNameWithoutExtension(filePath); + if (fileName == "StandardClassLibraryFormatter") + { + builder.Replace(" public sealed class ValueTaskFormatter", "#if NETCOREAPP\n public sealed class ValueTaskFormatter"); + builder.Replace(" }\n\n#endif\n}", " }\n#endif\n\n#endif\n}"); + } + else if (fileName == "ValueTupleFormatter") + { + builder.Replace("#if NETSTANDARD || NETFRAMEWORK", "#if NETSTANDARD || NETCOREAPP"); + } + else if (fileName == "DynamicAssembly") + { + builder.Replace("#if NETSTANDARD || NETFRAMEWORK", "#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP"); + } + else if (fileName == "LZ4Codec.Helper") + { + builder.Replace("#if NETSTANDARD || NETFRAMEWORK", "#if ENABLE_UNSAFE_MSGPACK"); + } + else if (fileName == "StandardResolver") + { + builder.Replace("#if !(NETSTANDARD || NETFRAMEWORK)", "#if !(NETSTANDARD || NETFRAMEWORK || NETCOREAPP)"); + } + else if (fileName == "DynamicGenericResolver") + { + builder.Replace(" // ValueTask", "#if NETCOREAPP\n // ValueTask"); + builder.Replace(" // ValueTuple", "#if NETCOREAPP\n // ValueTuple"); + builder.Replace(" // Tuple", "#endif\n // Tuple"); + builder.Replace(" // ArraySegement", "#endif\n // ArraySegment"); + builder.Replace("GetTypeInfo().IsConstructedGenericType()", "IsConstructedGenericType"); + } + + builder.Replace("#if NETSTANDARD || NETFRAMEWORK\n [System.Runtime.CompilerServices.MethodImpl", "#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP\n [System.Runtime.CompilerServices.MethodImpl"); + } // Debugger.Break() is a dangerous method that may crash the process. We don't // want to take any risk of calling it, ever, so replace it with a noop. diff --git a/tracer/dependabot/Datadog.Dependabot.Vendors.csproj b/tracer/dependabot/Datadog.Dependabot.Vendors.csproj index fd783463f..48b097033 100644 --- a/tracer/dependabot/Datadog.Dependabot.Vendors.csproj +++ b/tracer/dependabot/Datadog.Dependabot.Vendors.csproj @@ -15,8 +15,8 @@ - - + + diff --git a/tracer/src/Datadog.Trace/ExtensionMethods/MessagePackBinaryExtensions.cs b/tracer/src/Datadog.Trace/ExtensionMethods/MessagePackBinaryExtensions.cs new file mode 100644 index 000000000..5f6deffb8 --- /dev/null +++ b/tracer/src/Datadog.Trace/ExtensionMethods/MessagePackBinaryExtensions.cs @@ -0,0 +1,109 @@ +// +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache 2 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2017 Datadog, Inc. +// + +#if NETCOREAPP +using System; + +namespace Datadog.Trace.Vendors.MessagePack +{ + internal static partial class MessagePackBinary + { + public static int WriteRaw(ref byte[] bytes, int offset, ReadOnlySpan rawMessagePackBlock) + { + EnsureCapacity(ref bytes, offset, rawMessagePackBlock.Length); + rawMessagePackBlock.CopyTo(bytes.AsSpan(offset, rawMessagePackBlock.Length)); + return rawMessagePackBlock.Length; + } + + public static int WriteBytes(ref byte[] bytes, int offset, ReadOnlySpan rawMessagePackBlock) + { + var count = rawMessagePackBlock.Length; + if (count <= byte.MaxValue) + { + var size = count + 2; + EnsureCapacity(ref bytes, offset, size); + + bytes[offset] = MessagePackCode.Bin8; + bytes[offset + 1] = (byte)count; + + rawMessagePackBlock.CopyTo(bytes.AsSpan(offset + 2, count)); + return size; + } + else if (count <= ushort.MaxValue) + { + var size = count + 3; + EnsureCapacity(ref bytes, offset, size); + + unchecked + { + bytes[offset] = MessagePackCode.Bin16; + bytes[offset + 1] = (byte)(count >> 8); + bytes[offset + 2] = (byte)(count); + } + + rawMessagePackBlock.CopyTo(bytes.AsSpan(offset + 3, count)); + return size; + } + else + { + var size = count + 5; + EnsureCapacity(ref bytes, offset, size); + + unchecked + { + bytes[offset] = MessagePackCode.Bin32; + bytes[offset + 1] = (byte)(count >> 24); + bytes[offset + 2] = (byte)(count >> 16); + bytes[offset + 3] = (byte)(count >> 8); + bytes[offset + 4] = (byte)(count); + } + + rawMessagePackBlock.CopyTo(bytes.AsSpan(offset + 5, count)); + return size; + } + } + + public static int WriteStringBytes(ref byte[] bytes, int offset, ReadOnlySpan utf8stringBytes) + { + var byteCount = utf8stringBytes.Length; + if (byteCount <= MessagePackRange.MaxFixStringLength) + { + EnsureCapacity(ref bytes, offset, byteCount + 1); + bytes[offset] = (byte)(MessagePackCode.MinFixStr | byteCount); + utf8stringBytes.CopyTo(bytes.AsSpan(offset + 1, byteCount)); + return byteCount + 1; + } + else if (byteCount <= byte.MaxValue) + { + EnsureCapacity(ref bytes, offset, byteCount + 2); + bytes[offset] = MessagePackCode.Str8; + bytes[offset + 1] = unchecked((byte)byteCount); + utf8stringBytes.CopyTo(bytes.AsSpan(offset + 2, byteCount)); + return byteCount + 2; + } + else if (byteCount <= ushort.MaxValue) + { + EnsureCapacity(ref bytes, offset, byteCount + 3); + bytes[offset] = MessagePackCode.Str16; + bytes[offset + 1] = unchecked((byte)(byteCount >> 8)); + bytes[offset + 2] = unchecked((byte)byteCount); + utf8stringBytes.CopyTo(bytes.AsSpan(offset + 3, byteCount)); + return byteCount + 3; + } + else + { + EnsureCapacity(ref bytes, offset, byteCount + 5); + bytes[offset] = MessagePackCode.Str32; + bytes[offset + 1] = unchecked((byte)(byteCount >> 24)); + bytes[offset + 2] = unchecked((byte)(byteCount >> 16)); + bytes[offset + 3] = unchecked((byte)(byteCount >> 8)); + bytes[offset + 4] = unchecked((byte)byteCount); + utf8stringBytes.CopyTo(bytes.AsSpan(offset + 5, byteCount)); + return byteCount + 5; + } + } + } +} +#endif diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Attributes.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Attributes.cs index 3c9932611..5134a124f 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/Attributes.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Attributes.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 using System; namespace Datadog.Trace.Vendors.MessagePack diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/BitOperations.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/BitOperations.cs index 89d6e7024..e954f949f 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/BitOperations.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/BitOperations.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for more information. diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/FloatBits.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/FloatBits.cs index cb07b3529..9535b373d 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/FloatBits.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/FloatBits.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 using System; using System.Runtime.InteropServices; diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/CollectionFormatter.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/CollectionFormatter.cs index b0e906eb7..c1b6e5117 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/CollectionFormatter.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/CollectionFormatter.cs @@ -2,13 +2,14 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 using System; using System.Collections; using System.Collections.Generic; using System.Collections.ObjectModel; using System.Linq; -#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +#if NETSTANDARD || NETFRAMEWORK using System.Collections.Concurrent; #endif @@ -247,7 +248,7 @@ public int Serialize(ref byte[] bytes, int offset, TCollection value, IFormatter { while (e.MoveNext()) { -#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +#if NETSTANDARD || NETFRAMEWORK offset += formatter.Serialize(ref bytes, offset, e.Current, formatterResolver); #else offset += formatter.Serialize(ref bytes, (int)offset, (TElement)e.Current, (IFormatterResolver)formatterResolver); @@ -278,7 +279,7 @@ public int Serialize(ref byte[] bytes, int offset, TCollection value, IFormatter while (e.MoveNext()) { count++; -#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +#if NETSTANDARD || NETFRAMEWORK var writeSize = formatter.Serialize(ref bytes, offset, e.Current, formatterResolver); #else var writeSize = formatter.Serialize(ref bytes, (int)offset, (TElement)e.Current, (IFormatterResolver)formatterResolver); @@ -348,7 +349,7 @@ public TCollection Deserialize(byte[] bytes, int offset, IFormatterResolver form { return collection.Count; } -#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +#if NETSTANDARD || NETFRAMEWORK else { var c2 = sequence as IReadOnlyCollection; @@ -952,7 +953,7 @@ public IDictionary Deserialize(byte[] bytes, int offset, IFormatterResolver form } } -#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +#if NETSTANDARD || NETFRAMEWORK internal sealed class ObservableCollectionFormatter : CollectionFormatterBase> { diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/CollectionHelpers`2.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/CollectionHelpers`2.cs index 8f78c24f1..0af846cc3 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/CollectionHelpers`2.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/CollectionHelpers`2.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 // Copyright (c) All contributors. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/DictionaryFormatter.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/DictionaryFormatter.cs index fc75b4cc1..7112fa816 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/DictionaryFormatter.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/DictionaryFormatter.cs @@ -2,18 +2,19 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 using System; using System.Collections.Generic; using System.Collections.ObjectModel; -#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +#if NETSTANDARD || NETFRAMEWORK using System.Collections.Concurrent; #endif namespace Datadog.Trace.Vendors.MessagePack.Formatters { -#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +#if NETSTANDARD || NETFRAMEWORK // unfortunately, can't use IDictionary because supports IReadOnlyDictionary. internal abstract class DictionaryFormatterBase : IMessagePackFormatter diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/DynamicObjectTypeFallbackFormatter.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/DynamicObjectTypeFallbackFormatter.cs index 080d0ea47..76972994c 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/DynamicObjectTypeFallbackFormatter.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/DynamicObjectTypeFallbackFormatter.cs @@ -2,7 +2,8 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ -#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 +#if NETSTANDARD || NETFRAMEWORK using Datadog.Trace.Vendors.MessagePack.Resolvers; using System; diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/EnumAsStringFormatter.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/EnumAsStringFormatter.cs index 4aceb9e76..81281971d 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/EnumAsStringFormatter.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/EnumAsStringFormatter.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 using System; using System.Collections.Generic; diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/ForceSizePrimitiveFormatter.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/ForceSizePrimitiveFormatter.cs index 7bf7133a2..8d0423e8b 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/ForceSizePrimitiveFormatter.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/ForceSizePrimitiveFormatter.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 using System; namespace Datadog.Trace.Vendors.MessagePack.Formatters diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/IMessagePackFormatter.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/IMessagePackFormatter.cs index 95711e188..d383d58e2 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/IMessagePackFormatter.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/IMessagePackFormatter.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 namespace Datadog.Trace.Vendors.MessagePack.Formatters { diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/IgnoreFormatter.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/IgnoreFormatter.cs index 12c99741b..7fb5b467d 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/IgnoreFormatter.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/IgnoreFormatter.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 namespace Datadog.Trace.Vendors.MessagePack.Formatters { internal sealed class IgnoreFormatter : IMessagePackFormatter diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/MultiDimentionalArrayFormatter.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/MultiDimentionalArrayFormatter.cs index ff316fad6..fff66c75a 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/MultiDimentionalArrayFormatter.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/MultiDimentionalArrayFormatter.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 using System; using System.Collections.Generic; using System.Text; diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/NullableFormatter.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/NullableFormatter.cs index caae603c6..906cd179d 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/NullableFormatter.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/NullableFormatter.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 using System; using System.Collections.Generic; using System.Text; diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/OldSpecFormatter.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/OldSpecFormatter.cs index 1e4a8269b..1bcc5286a 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/OldSpecFormatter.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/OldSpecFormatter.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 using System; namespace Datadog.Trace.Vendors.MessagePack.Formatters diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/PrimitiveFormatter.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/PrimitiveFormatter.cs index d1f893767..e8704d7e9 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/PrimitiveFormatter.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/PrimitiveFormatter.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 using System; namespace Datadog.Trace.Vendors.MessagePack.Formatters diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/PrimitiveObjectFormatter.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/PrimitiveObjectFormatter.cs index bfbf6b39c..64b76ac1e 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/PrimitiveObjectFormatter.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/PrimitiveObjectFormatter.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 using System; using System.Reflection; using System.Collections.Generic; diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/StandardClassLibraryFormatter.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/StandardClassLibraryFormatter.cs index c0a90750e..a68be2c22 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/StandardClassLibraryFormatter.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/StandardClassLibraryFormatter.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 using Datadog.Trace.Vendors.MessagePack.Internal; using System; using System.Collections; @@ -9,7 +10,7 @@ using System.Globalization; using System.Text; -#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +#if NETSTANDARD || NETFRAMEWORK using System.Threading.Tasks; #endif @@ -411,7 +412,7 @@ public BitArray Deserialize(byte[] bytes, int offset, IFormatterResolver formatt } } -#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +#if NETSTANDARD || NETFRAMEWORK internal sealed class BigIntegerFormatter : IMessagePackFormatter { @@ -570,5 +571,21 @@ public Task Deserialize(byte[] bytes, int offset, IFormatterResolver formatte } } +#if NETCOREAPP + internal sealed class ValueTaskFormatter : IMessagePackFormatter> + { + public int Serialize(ref byte[] bytes, int offset, ValueTask value, IFormatterResolver formatterResolver) + { + return formatterResolver.GetFormatterWithVerify().Serialize(ref bytes, offset, value.Result, formatterResolver); + } + + public ValueTask Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize) + { + var v = formatterResolver.GetFormatterWithVerify().Deserialize(bytes, offset, formatterResolver, out readSize); + return new ValueTask(v); + } + } +#endif + #endif -} +} \ No newline at end of file diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/TupleFormatter.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/TupleFormatter.cs index 40b536200..6bdccb09f 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/TupleFormatter.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/TupleFormatter.cs @@ -2,7 +2,8 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ -#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 +#if NETSTANDARD || NETFRAMEWORK using System; diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/TupleFormatter.tt b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/TupleFormatter.tt index bf69acf71..e6c3c3c6a 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/TupleFormatter.tt +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/TupleFormatter.tt @@ -4,7 +4,7 @@ <#@ import namespace="System.Text" #> <#@ import namespace="System.Collections.Generic" #> <#@ output extension=".cs" #> -#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +#if NETSTANDARD || NETFRAMEWORK using System; diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/TypelessFormatter.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/TypelessFormatter.cs new file mode 100644 index 000000000..8c2cfd71b --- /dev/null +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/TypelessFormatter.cs @@ -0,0 +1,339 @@ +//------------------------------------------------------------------------------ +// +// This file was automatically generated by the UpdateVendors tool. +//------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 +#if NETSTANDARD || NETFRAMEWORK + +using Datadog.Trace.Vendors.MessagePack.Internal; +using System; +using System.Collections; +using System.Collections.Concurrent; +using System.Collections.Generic; +using System.Linq.Expressions; +using System.Reflection; +using System.Text.RegularExpressions; + +namespace Datadog.Trace.Vendors.MessagePack.Formatters +{ + /// + /// For `object` field that holds derived from `object` value, ex: var arr = new object[] { 1, "a", new Model() }; + /// + internal sealed class TypelessFormatter : IMessagePackFormatter + { + public const sbyte ExtensionTypeCode = 100; + + static readonly Regex SubtractFullNameRegex = new Regex(@", Version=\d+.\d+.\d+.\d+, Culture=\w+, PublicKeyToken=\w+", RegexOptions.Compiled); + + delegate int SerializeMethod(object dynamicContractlessFormatter, ref byte[] bytes, int offset, object value, IFormatterResolver formatterResolver); + delegate object DeserializeMethod(object dynamicContractlessFormatter, byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize); + + public static readonly IMessagePackFormatter Instance = new TypelessFormatter(); + + static readonly ThreadsafeTypeKeyHashTable> serializers = new ThreadsafeTypeKeyHashTable>(); + static readonly ThreadsafeTypeKeyHashTable> deserializers = new ThreadsafeTypeKeyHashTable>(); + static readonly ThreadsafeTypeKeyHashTable typeNameCache = new ThreadsafeTypeKeyHashTable(); + static readonly AsymmetricKeyHashTable, Type> typeCache = new AsymmetricKeyHashTable, Type>(new StringArraySegmentByteAscymmetricEqualityComparer()); + + static readonly HashSet blacklistCheck; + static readonly HashSet useBuiltinTypes = new HashSet() + { + typeof(Boolean), + // typeof(Char), + typeof(SByte), + typeof(Byte), + typeof(Int16), + typeof(UInt16), + typeof(Int32), + typeof(UInt32), + typeof(Int64), + typeof(UInt64), + typeof(Single), + typeof(Double), + typeof(string), + typeof(byte[]), + + // array should save there types. + //typeof(Boolean[]), + //typeof(Char[]), + //typeof(SByte[]), + //typeof(Int16[]), + //typeof(UInt16[]), + //typeof(Int32[]), + //typeof(UInt32[]), + //typeof(Int64[]), + //typeof(UInt64[]), + //typeof(Single[]), + //typeof(Double[]), + //typeof(string[]), + + typeof(Boolean?), + // typeof(Char?), + typeof(SByte?), + typeof(Byte?), + typeof(Int16?), + typeof(UInt16?), + typeof(Int32?), + typeof(UInt32?), + typeof(Int64?), + typeof(UInt64?), + typeof(Single?), + typeof(Double?), + }; + + public static Func BindToType { get; set; } + + static Type DefaultBindToType(string typeName) + { + return Type.GetType(typeName, false); + } + + // mscorlib or System.Private.CoreLib + static bool isMscorlib = typeof(int).AssemblyQualifiedName.Contains("mscorlib"); + + /// + /// When type name does not have Version, Culture, Public token - sometimes can not find type, example - ExpandoObject + /// In that can set to `false` + /// + public static volatile bool RemoveAssemblyVersion = true; + + static TypelessFormatter() + { + blacklistCheck = new HashSet() + { + "System.CodeDom.Compiler.TempFileCollection", + "System.IO.FileSystemInfo", + "System.Management.IWbemClassObjectFreeThreaded" + }; + + serializers.TryAdd(typeof(object), _ => new KeyValuePair(null, (object p1, ref byte[] p2, int p3, object p4, IFormatterResolver p5) => 0)); + deserializers.TryAdd(typeof(object), _ => new KeyValuePair(null, (object p1, byte[] p2, int p3, IFormatterResolver p4, out int p5) => + { + p5 = 0; + return new object(); + })); + + BindToType = DefaultBindToType; + } + + // see:http://msdn.microsoft.com/en-us/library/w3f99sx1.aspx + // subtract Version, Culture and PublicKeyToken from AssemblyQualifiedName + static string BuildTypeName(Type type) + { + if (RemoveAssemblyVersion) + { + string full = type.AssemblyQualifiedName; + + var shortened = SubtractFullNameRegex.Replace(full, ""); + if (Type.GetType(shortened, false) == null) + { + // if type cannot be found with shortened name - use full name + shortened = full; + } + + return shortened; + } + else + { + return type.AssemblyQualifiedName; + } + } + + public int Serialize(ref byte[] bytes, int offset, object value, IFormatterResolver formatterResolver) + { + if (value == null) + { + return MessagePackBinary.WriteNil(ref bytes, offset); + } + + var type = value.GetType(); + + byte[] typeName; + if (!typeNameCache.TryGetValue(type, out typeName)) + { + if (blacklistCheck.Contains(type.FullName)) + { + throw new InvalidOperationException("Type is in blacklist:" + type.FullName); + } + + var ti = type.GetTypeInfo(); + if (ti.IsAnonymous() || useBuiltinTypes.Contains(type)) + { + typeName = null; + } + else + { + typeName = StringEncoding.UTF8.GetBytes(BuildTypeName(type)); + } + typeNameCache.TryAdd(type, typeName); + } + + if (typeName == null) + { + return Resolvers.TypelessFormatterFallbackResolver.Instance.GetFormatter().Serialize(ref bytes, offset, value, formatterResolver); + } + + // don't use GetOrAdd for avoid closure capture. + KeyValuePair formatterAndDelegate; + if (!serializers.TryGetValue(type, out formatterAndDelegate)) + { + lock (serializers) // double check locking... + { + if (!serializers.TryGetValue(type, out formatterAndDelegate)) + { + var ti = type.GetTypeInfo(); + + var formatter = formatterResolver.GetFormatterDynamic(type); + if (formatter == null) + { + throw new FormatterNotRegisteredException(type.FullName + " is not registered in this resolver. resolver:" + formatterResolver.GetType().Name); + } + + var formatterType = typeof(IMessagePackFormatter<>).MakeGenericType(type); + var param0 = Expression.Parameter(typeof(object), "formatter"); + var param1 = Expression.Parameter(typeof(byte[]).MakeByRefType(), "bytes"); + var param2 = Expression.Parameter(typeof(int), "offset"); + var param3 = Expression.Parameter(typeof(object), "value"); + var param4 = Expression.Parameter(typeof(IFormatterResolver), "formatterResolver"); + + var serializeMethodInfo = formatterType.GetRuntimeMethod("Serialize", new[] { typeof(byte[]).MakeByRefType(), typeof(int), type, typeof(IFormatterResolver) }); + + var body = Expression.Call( + Expression.Convert(param0, formatterType), + serializeMethodInfo, + param1, + param2, + ti.IsValueType ? Expression.Unbox(param3, type) : Expression.Convert(param3, type), + param4); + + var lambda = Expression.Lambda(body, param0, param1, param2, param3, param4).Compile(); + + formatterAndDelegate = new KeyValuePair(formatter, lambda); + serializers.TryAdd(type, formatterAndDelegate); + } + } + } + + // mark as extension with code 100 + var startOffset = offset; + offset += 6; // mark will be written at the end, when size is known + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, typeName); + offset += formatterAndDelegate.Value(formatterAndDelegate.Key, ref bytes, offset, value, formatterResolver); + MessagePackBinary.WriteExtensionFormatHeaderForceExt32Block(ref bytes, startOffset, (sbyte)TypelessFormatter.ExtensionTypeCode, offset - startOffset - 6); + return offset - startOffset; + } + + public object Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize) + { + if (MessagePackBinary.IsNil(bytes, offset)) + { + readSize = 1; + return null; + } + + int startOffset = offset; + var packType = MessagePackBinary.GetMessagePackType(bytes, offset); + if (packType == MessagePackType.Extension) + { + var ext = MessagePackBinary.ReadExtensionFormatHeader(bytes, offset, out readSize); + if (ext.TypeCode == TypelessFormatter.ExtensionTypeCode) + { + // it has type name serialized + offset += readSize; + var typeName = MessagePackBinary.ReadStringSegment(bytes, offset, out readSize); + offset += readSize; + var result = DeserializeByTypeName(typeName, bytes, offset, formatterResolver, out readSize); + offset += readSize; + readSize = offset - startOffset; + return result; + } + } + + // fallback + return Resolvers.TypelessFormatterFallbackResolver.Instance.GetFormatter().Deserialize(bytes, startOffset, formatterResolver, out readSize); + } + + /// + /// Does not support deserializing of anonymous types + /// Type should be covered by preceeding resolvers in complex/standard resolver + /// + private object DeserializeByTypeName(ArraySegment typeName, byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize) + { + // try get type with assembly name, throw if not found + Type type; + if (!typeCache.TryGetValue(typeName, out type)) + { + var buffer = new byte[typeName.Count]; + Buffer.BlockCopy(typeName.Array, typeName.Offset, buffer, 0, buffer.Length); + var str = StringEncoding.UTF8.GetString(buffer); + type = BindToType(str); + if (type == null) + { + if (isMscorlib && str.Contains("System.Private.CoreLib")) + { + str = str.Replace("System.Private.CoreLib", "mscorlib"); + type = Type.GetType(str, true); // throw + } + else if (!isMscorlib && str.Contains("mscorlib")) + { + str = str.Replace("mscorlib", "System.Private.CoreLib"); + type = Type.GetType(str, true); // throw + } + else + { + type = Type.GetType(str, true); // re-throw + } + } + typeCache.TryAdd(buffer, type); + } + + KeyValuePair formatterAndDelegate; + if (!deserializers.TryGetValue(type, out formatterAndDelegate)) + { + lock (deserializers) + { + if (!deserializers.TryGetValue(type, out formatterAndDelegate)) + { + var ti = type.GetTypeInfo(); + + var formatter = formatterResolver.GetFormatterDynamic(type); + if (formatter == null) + { + throw new FormatterNotRegisteredException(type.FullName + " is not registered in this resolver. resolver:" + formatterResolver.GetType().Name); + } + + var formatterType = typeof(IMessagePackFormatter<>).MakeGenericType(type); + var param0 = Expression.Parameter(typeof(object), "formatter"); + var param1 = Expression.Parameter(typeof(byte[]), "bytes"); + var param2 = Expression.Parameter(typeof(int), "offset"); + var param3 = Expression.Parameter(typeof(IFormatterResolver), "formatterResolver"); + var param4 = Expression.Parameter(typeof(int).MakeByRefType(), "readSize"); + + var deserializeMethodInfo = formatterType.GetRuntimeMethod("Deserialize", new[] { typeof(byte[]), typeof(int), typeof(IFormatterResolver), typeof(int).MakeByRefType() }); + + var deserialize = Expression.Call( + Expression.Convert(param0, formatterType), + deserializeMethodInfo, + param1, + param2, + param3, + param4); + + Expression body = deserialize; + if (ti.IsValueType) + body = Expression.Convert(deserialize, typeof(object)); + var lambda = Expression.Lambda(body, param0, param1, param2, param3, param4).Compile(); + + formatterAndDelegate = new KeyValuePair(formatter, lambda); + deserializers.TryAdd(type, formatterAndDelegate); + } + } + } + + return formatterAndDelegate.Value(formatterAndDelegate.Key, bytes, offset, formatterResolver, out readSize); + } + } + +} + +#endif \ No newline at end of file diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/UnsafeBinaryFormatters.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/UnsafeBinaryFormatters.cs new file mode 100644 index 000000000..7f6b50bd8 --- /dev/null +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/UnsafeBinaryFormatters.cs @@ -0,0 +1,131 @@ +//------------------------------------------------------------------------------ +// +// This file was automatically generated by the UpdateVendors tool. +//------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 +#if NETSTANDARD || NETFRAMEWORK + +using System; + +namespace Datadog.Trace.Vendors.MessagePack.Formatters +{ + internal sealed class BinaryGuidFormatter : IMessagePackFormatter + { + /// + /// Unsafe binary Guid formatter. this is only allows on LittleEndian environment. + /// + public static readonly IMessagePackFormatter Instance = new BinaryGuidFormatter(); + + BinaryGuidFormatter() + { + } + + // Guid's underlying _a,...,_k field is sequential and same layuout as .NET Framework and Mono(Unity). + // But target machines must be same endian so restrict only for little endian. + + public unsafe int Serialize(ref byte[] bytes, int offset, Guid value, IFormatterResolver formatterResolver) + { + if (!BitConverter.IsLittleEndian) throw new Exception("BinaryGuidFormatter only allows on little endian env."); + + MessagePackBinary.EnsureCapacity(ref bytes, offset, 18); + fixed (byte* dst = &bytes[offset]) + { + var src = &value; + + dst[0] = MessagePackCode.Bin8; + dst[1] = 16; + + *(Guid*)(dst + 2) = *src; + } + + return 18; + } + + public unsafe Guid Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize) + { + if (!BitConverter.IsLittleEndian) throw new Exception("BinaryGuidFormatter only allows on little endian env."); + + if (!(offset + 18 <= bytes.Length)) + { + throw new ArgumentOutOfRangeException(); + } + + fixed (byte* src = &bytes[offset]) + { + if (src[0] != MessagePackCode.Bin8) + { + throw new InvalidOperationException(string.Format("code is invalid. code:{0} format:{1}", bytes[offset], MessagePackCode.ToFormatName(bytes[offset]))); + } + if (src[1] != 16) + { + throw new InvalidOperationException("Invalid Guid Size."); + } + + var target = *(Guid*)(src + 2); + readSize = 18; + return target; + } + } + } + + internal sealed class BinaryDecimalFormatter : IMessagePackFormatter + { + /// + /// Unsafe binary Decimal formatter. this is only allows on LittleEndian environment. + /// + public static readonly IMessagePackFormatter Instance = new BinaryDecimalFormatter(); + + BinaryDecimalFormatter() + { + } + + // decimal underlying "flags, hi, lo, mid" fields are sequential and same layuout with .NET Framework and Mono(Unity) + // But target machines must be same endian so restrict only for little endian. + + public unsafe int Serialize(ref byte[] bytes, int offset, Decimal value, IFormatterResolver formatterResolver) + { + if (!BitConverter.IsLittleEndian) throw new Exception("BinaryGuidFormatter only allows on little endian env."); + + MessagePackBinary.EnsureCapacity(ref bytes, offset, 18); + fixed (byte* dst = &bytes[offset]) + { + var src = &value; + + dst[0] = MessagePackCode.Bin8; + dst[1] = 16; + + *(Decimal*)(dst + 2) = *src; + } + + return 18; + } + + public unsafe Decimal Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize) + { + if (!BitConverter.IsLittleEndian) throw new Exception("BinaryDecimalFormatter only allows on little endian env."); + + if (!(offset + 18 <= bytes.Length)) + { + throw new ArgumentOutOfRangeException(); + } + + fixed (byte* src = &bytes[offset]) + { + if (src[0] != MessagePackCode.Bin8) + { + throw new InvalidOperationException(string.Format("code is invalid. code:{0} format:{1}", bytes[offset], MessagePackCode.ToFormatName(bytes[offset]))); + } + if (src[1] != 16) + { + throw new InvalidOperationException("Invalid Guid Size."); + } + + var target = *(Decimal*)(src + 2); + readSize = 18; + return target; + } + } + } +} + +#endif \ No newline at end of file diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/ValueTupleFormatter.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/ValueTupleFormatter.cs new file mode 100644 index 000000000..7876f6bdb --- /dev/null +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/ValueTupleFormatter.cs @@ -0,0 +1,400 @@ +//------------------------------------------------------------------------------ +// +// This file was automatically generated by the UpdateVendors tool. +//------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 +#if NETSTANDARD || NETCOREAPP +using System; + +namespace Datadog.Trace.Vendors.MessagePack.Formatters +{ + + internal sealed class ValueTupleFormatter : IMessagePackFormatter> + { + public int Serialize(ref byte[] bytes, int offset, ValueTuple value, IFormatterResolver formatterResolver) + { + var startOffset = offset; + offset += MessagePackBinary.WriteArrayHeader(ref bytes, offset, 1); + + offset += formatterResolver.GetFormatterWithVerify().Serialize(ref bytes, offset, value.Item1, formatterResolver); + + return offset - startOffset; + } + + public ValueTuple Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize) + { + if (MessagePackBinary.IsNil(bytes, offset)) + { + throw new InvalidOperationException("Data is Nil, ValueTuple can not be null."); + } + else + { + var startOffset = offset; + var count = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); + if (count != 1) throw new InvalidOperationException("Invalid ValueTuple count"); + offset += readSize; + + using (MessagePackSecurity.DepthStep()) + { + var item1 = formatterResolver.GetFormatterWithVerify().Deserialize(bytes, offset, formatterResolver, out readSize); + offset += readSize; + + readSize = offset - startOffset; + return new ValueTuple(item1); + } + } + } + } + + + internal sealed class ValueTupleFormatter : IMessagePackFormatter> + { + public int Serialize(ref byte[] bytes, int offset, ValueTuple value, IFormatterResolver formatterResolver) + { + var startOffset = offset; + offset += MessagePackBinary.WriteArrayHeader(ref bytes, offset, 2); + + offset += formatterResolver.GetFormatterWithVerify().Serialize(ref bytes, offset, value.Item1, formatterResolver); + offset += formatterResolver.GetFormatterWithVerify().Serialize(ref bytes, offset, value.Item2, formatterResolver); + + return offset - startOffset; + } + + public ValueTuple Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize) + { + if (MessagePackBinary.IsNil(bytes, offset)) + { + throw new InvalidOperationException("Data is Nil, ValueTuple can not be null."); + } + else + { + var startOffset = offset; + var count = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); + if (count != 2) throw new InvalidOperationException("Invalid ValueTuple count"); + offset += readSize; + + using (MessagePackSecurity.DepthStep()) + { + var item1 = formatterResolver.GetFormatterWithVerify().Deserialize(bytes, offset, formatterResolver, out readSize); + offset += readSize; + var item2 = formatterResolver.GetFormatterWithVerify().Deserialize(bytes, offset, formatterResolver, out readSize); + offset += readSize; + + readSize = offset - startOffset; + return new ValueTuple(item1, item2); + } + } + } + } + + + internal sealed class ValueTupleFormatter : IMessagePackFormatter> + { + public int Serialize(ref byte[] bytes, int offset, ValueTuple value, IFormatterResolver formatterResolver) + { + var startOffset = offset; + offset += MessagePackBinary.WriteArrayHeader(ref bytes, offset, 3); + + offset += formatterResolver.GetFormatterWithVerify().Serialize(ref bytes, offset, value.Item1, formatterResolver); + offset += formatterResolver.GetFormatterWithVerify().Serialize(ref bytes, offset, value.Item2, formatterResolver); + offset += formatterResolver.GetFormatterWithVerify().Serialize(ref bytes, offset, value.Item3, formatterResolver); + + return offset - startOffset; + } + + public ValueTuple Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize) + { + if (MessagePackBinary.IsNil(bytes, offset)) + { + throw new InvalidOperationException("Data is Nil, ValueTuple can not be null."); + } + else + { + var startOffset = offset; + var count = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); + if (count != 3) throw new InvalidOperationException("Invalid ValueTuple count"); + offset += readSize; + + using (MessagePackSecurity.DepthStep()) + { + var item1 = formatterResolver.GetFormatterWithVerify().Deserialize(bytes, offset, formatterResolver, out readSize); + offset += readSize; + var item2 = formatterResolver.GetFormatterWithVerify().Deserialize(bytes, offset, formatterResolver, out readSize); + offset += readSize; + var item3 = formatterResolver.GetFormatterWithVerify().Deserialize(bytes, offset, formatterResolver, out readSize); + offset += readSize; + + readSize = offset - startOffset; + return new ValueTuple(item1, item2, item3); + } + } + } + } + + + internal sealed class ValueTupleFormatter : IMessagePackFormatter> + { + public int Serialize(ref byte[] bytes, int offset, ValueTuple value, IFormatterResolver formatterResolver) + { + var startOffset = offset; + offset += MessagePackBinary.WriteArrayHeader(ref bytes, offset, 4); + + offset += formatterResolver.GetFormatterWithVerify().Serialize(ref bytes, offset, value.Item1, formatterResolver); + offset += formatterResolver.GetFormatterWithVerify().Serialize(ref bytes, offset, value.Item2, formatterResolver); + offset += formatterResolver.GetFormatterWithVerify().Serialize(ref bytes, offset, value.Item3, formatterResolver); + offset += formatterResolver.GetFormatterWithVerify().Serialize(ref bytes, offset, value.Item4, formatterResolver); + + return offset - startOffset; + } + + public ValueTuple Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize) + { + if (MessagePackBinary.IsNil(bytes, offset)) + { + throw new InvalidOperationException("Data is Nil, ValueTuple can not be null."); + } + else + { + var startOffset = offset; + var count = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); + if (count != 4) throw new InvalidOperationException("Invalid ValueTuple count"); + offset += readSize; + + using (MessagePackSecurity.DepthStep()) + { + var item1 = formatterResolver.GetFormatterWithVerify().Deserialize(bytes, offset, formatterResolver, out readSize); + offset += readSize; + var item2 = formatterResolver.GetFormatterWithVerify().Deserialize(bytes, offset, formatterResolver, out readSize); + offset += readSize; + var item3 = formatterResolver.GetFormatterWithVerify().Deserialize(bytes, offset, formatterResolver, out readSize); + offset += readSize; + var item4 = formatterResolver.GetFormatterWithVerify().Deserialize(bytes, offset, formatterResolver, out readSize); + offset += readSize; + + readSize = offset - startOffset; + return new ValueTuple(item1, item2, item3, item4); + } + } + } + } + + + internal sealed class ValueTupleFormatter : IMessagePackFormatter> + { + public int Serialize(ref byte[] bytes, int offset, ValueTuple value, IFormatterResolver formatterResolver) + { + var startOffset = offset; + offset += MessagePackBinary.WriteArrayHeader(ref bytes, offset, 5); + + offset += formatterResolver.GetFormatterWithVerify().Serialize(ref bytes, offset, value.Item1, formatterResolver); + offset += formatterResolver.GetFormatterWithVerify().Serialize(ref bytes, offset, value.Item2, formatterResolver); + offset += formatterResolver.GetFormatterWithVerify().Serialize(ref bytes, offset, value.Item3, formatterResolver); + offset += formatterResolver.GetFormatterWithVerify().Serialize(ref bytes, offset, value.Item4, formatterResolver); + offset += formatterResolver.GetFormatterWithVerify().Serialize(ref bytes, offset, value.Item5, formatterResolver); + + return offset - startOffset; + } + + public ValueTuple Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize) + { + if (MessagePackBinary.IsNil(bytes, offset)) + { + throw new InvalidOperationException("Data is Nil, ValueTuple can not be null."); + } + else + { + var startOffset = offset; + var count = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); + if (count != 5) throw new InvalidOperationException("Invalid ValueTuple count"); + offset += readSize; + + using (MessagePackSecurity.DepthStep()) + { + var item1 = formatterResolver.GetFormatterWithVerify().Deserialize(bytes, offset, formatterResolver, out readSize); + offset += readSize; + var item2 = formatterResolver.GetFormatterWithVerify().Deserialize(bytes, offset, formatterResolver, out readSize); + offset += readSize; + var item3 = formatterResolver.GetFormatterWithVerify().Deserialize(bytes, offset, formatterResolver, out readSize); + offset += readSize; + var item4 = formatterResolver.GetFormatterWithVerify().Deserialize(bytes, offset, formatterResolver, out readSize); + offset += readSize; + var item5 = formatterResolver.GetFormatterWithVerify().Deserialize(bytes, offset, formatterResolver, out readSize); + offset += readSize; + + readSize = offset - startOffset; + return new ValueTuple(item1, item2, item3, item4, item5); + } + } + } + } + + + internal sealed class ValueTupleFormatter : IMessagePackFormatter> + { + public int Serialize(ref byte[] bytes, int offset, ValueTuple value, IFormatterResolver formatterResolver) + { + var startOffset = offset; + offset += MessagePackBinary.WriteArrayHeader(ref bytes, offset, 6); + + offset += formatterResolver.GetFormatterWithVerify().Serialize(ref bytes, offset, value.Item1, formatterResolver); + offset += formatterResolver.GetFormatterWithVerify().Serialize(ref bytes, offset, value.Item2, formatterResolver); + offset += formatterResolver.GetFormatterWithVerify().Serialize(ref bytes, offset, value.Item3, formatterResolver); + offset += formatterResolver.GetFormatterWithVerify().Serialize(ref bytes, offset, value.Item4, formatterResolver); + offset += formatterResolver.GetFormatterWithVerify().Serialize(ref bytes, offset, value.Item5, formatterResolver); + offset += formatterResolver.GetFormatterWithVerify().Serialize(ref bytes, offset, value.Item6, formatterResolver); + + return offset - startOffset; + } + + public ValueTuple Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize) + { + if (MessagePackBinary.IsNil(bytes, offset)) + { + throw new InvalidOperationException("Data is Nil, ValueTuple can not be null."); + } + else + { + var startOffset = offset; + var count = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); + if (count != 6) throw new InvalidOperationException("Invalid ValueTuple count"); + offset += readSize; + + using (MessagePackSecurity.DepthStep()) + { + var item1 = formatterResolver.GetFormatterWithVerify().Deserialize(bytes, offset, formatterResolver, out readSize); + offset += readSize; + var item2 = formatterResolver.GetFormatterWithVerify().Deserialize(bytes, offset, formatterResolver, out readSize); + offset += readSize; + var item3 = formatterResolver.GetFormatterWithVerify().Deserialize(bytes, offset, formatterResolver, out readSize); + offset += readSize; + var item4 = formatterResolver.GetFormatterWithVerify().Deserialize(bytes, offset, formatterResolver, out readSize); + offset += readSize; + var item5 = formatterResolver.GetFormatterWithVerify().Deserialize(bytes, offset, formatterResolver, out readSize); + offset += readSize; + var item6 = formatterResolver.GetFormatterWithVerify().Deserialize(bytes, offset, formatterResolver, out readSize); + offset += readSize; + + readSize = offset - startOffset; + return new ValueTuple(item1, item2, item3, item4, item5, item6); + } + } + } + } + + + internal sealed class ValueTupleFormatter : IMessagePackFormatter> + { + public int Serialize(ref byte[] bytes, int offset, ValueTuple value, IFormatterResolver formatterResolver) + { + var startOffset = offset; + offset += MessagePackBinary.WriteArrayHeader(ref bytes, offset, 7); + + offset += formatterResolver.GetFormatterWithVerify().Serialize(ref bytes, offset, value.Item1, formatterResolver); + offset += formatterResolver.GetFormatterWithVerify().Serialize(ref bytes, offset, value.Item2, formatterResolver); + offset += formatterResolver.GetFormatterWithVerify().Serialize(ref bytes, offset, value.Item3, formatterResolver); + offset += formatterResolver.GetFormatterWithVerify().Serialize(ref bytes, offset, value.Item4, formatterResolver); + offset += formatterResolver.GetFormatterWithVerify().Serialize(ref bytes, offset, value.Item5, formatterResolver); + offset += formatterResolver.GetFormatterWithVerify().Serialize(ref bytes, offset, value.Item6, formatterResolver); + offset += formatterResolver.GetFormatterWithVerify().Serialize(ref bytes, offset, value.Item7, formatterResolver); + + return offset - startOffset; + } + + public ValueTuple Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize) + { + if (MessagePackBinary.IsNil(bytes, offset)) + { + throw new InvalidOperationException("Data is Nil, ValueTuple can not be null."); + } + else + { + var startOffset = offset; + var count = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); + if (count != 7) throw new InvalidOperationException("Invalid ValueTuple count"); + offset += readSize; + + using (MessagePackSecurity.DepthStep()) + { + var item1 = formatterResolver.GetFormatterWithVerify().Deserialize(bytes, offset, formatterResolver, out readSize); + offset += readSize; + var item2 = formatterResolver.GetFormatterWithVerify().Deserialize(bytes, offset, formatterResolver, out readSize); + offset += readSize; + var item3 = formatterResolver.GetFormatterWithVerify().Deserialize(bytes, offset, formatterResolver, out readSize); + offset += readSize; + var item4 = formatterResolver.GetFormatterWithVerify().Deserialize(bytes, offset, formatterResolver, out readSize); + offset += readSize; + var item5 = formatterResolver.GetFormatterWithVerify().Deserialize(bytes, offset, formatterResolver, out readSize); + offset += readSize; + var item6 = formatterResolver.GetFormatterWithVerify().Deserialize(bytes, offset, formatterResolver, out readSize); + offset += readSize; + var item7 = formatterResolver.GetFormatterWithVerify().Deserialize(bytes, offset, formatterResolver, out readSize); + offset += readSize; + + readSize = offset - startOffset; + return new ValueTuple(item1, item2, item3, item4, item5, item6, item7); + } + } + } + } + + + internal sealed class ValueTupleFormatter : IMessagePackFormatter> where TRest : struct + { + public int Serialize(ref byte[] bytes, int offset, ValueTuple value, IFormatterResolver formatterResolver) + { + var startOffset = offset; + offset += MessagePackBinary.WriteArrayHeader(ref bytes, offset, 8); + + offset += formatterResolver.GetFormatterWithVerify().Serialize(ref bytes, offset, value.Item1, formatterResolver); + offset += formatterResolver.GetFormatterWithVerify().Serialize(ref bytes, offset, value.Item2, formatterResolver); + offset += formatterResolver.GetFormatterWithVerify().Serialize(ref bytes, offset, value.Item3, formatterResolver); + offset += formatterResolver.GetFormatterWithVerify().Serialize(ref bytes, offset, value.Item4, formatterResolver); + offset += formatterResolver.GetFormatterWithVerify().Serialize(ref bytes, offset, value.Item5, formatterResolver); + offset += formatterResolver.GetFormatterWithVerify().Serialize(ref bytes, offset, value.Item6, formatterResolver); + offset += formatterResolver.GetFormatterWithVerify().Serialize(ref bytes, offset, value.Item7, formatterResolver); + offset += formatterResolver.GetFormatterWithVerify().Serialize(ref bytes, offset, value.Rest, formatterResolver); + + return offset - startOffset; + } + + public ValueTuple Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize) + { + if (MessagePackBinary.IsNil(bytes, offset)) + { + throw new InvalidOperationException("Data is Nil, ValueTuple can not be null."); + } + else + { + var startOffset = offset; + var count = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); + if (count != 8) throw new InvalidOperationException("Invalid ValueTuple count"); + offset += readSize; + + using (MessagePackSecurity.DepthStep()) + { + var item1 = formatterResolver.GetFormatterWithVerify().Deserialize(bytes, offset, formatterResolver, out readSize); + offset += readSize; + var item2 = formatterResolver.GetFormatterWithVerify().Deserialize(bytes, offset, formatterResolver, out readSize); + offset += readSize; + var item3 = formatterResolver.GetFormatterWithVerify().Deserialize(bytes, offset, formatterResolver, out readSize); + offset += readSize; + var item4 = formatterResolver.GetFormatterWithVerify().Deserialize(bytes, offset, formatterResolver, out readSize); + offset += readSize; + var item5 = formatterResolver.GetFormatterWithVerify().Deserialize(bytes, offset, formatterResolver, out readSize); + offset += readSize; + var item6 = formatterResolver.GetFormatterWithVerify().Deserialize(bytes, offset, formatterResolver, out readSize); + offset += readSize; + var item7 = formatterResolver.GetFormatterWithVerify().Deserialize(bytes, offset, formatterResolver, out readSize); + offset += readSize; + var item8 = formatterResolver.GetFormatterWithVerify().Deserialize(bytes, offset, formatterResolver, out readSize); + offset += readSize; + + readSize = offset - startOffset; + return new ValueTuple(item1, item2, item3, item4, item5, item6, item7, item8); + } + } + } + } + +} +#endif \ No newline at end of file diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/ValueTupleFormatter.tt b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/ValueTupleFormatter.tt index 2958e5272..73ef261a7 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/ValueTupleFormatter.tt +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Formatters/ValueTupleFormatter.tt @@ -4,7 +4,7 @@ <#@ import namespace="System.Text" #> <#@ import namespace="System.Collections.Generic" #> <#@ output extension=".cs" #> -#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +#if NETSTANDARD || NETFRAMEWORK using System; namespace MessagePack.Formatters diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/HashCode.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/HashCode.cs index b20fc8076..b73ab9597 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/HashCode.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/HashCode.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for more information. diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/IFormatterResolver.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/IFormatterResolver.cs index 6a1666a0f..ea331923a 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/IFormatterResolver.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/IFormatterResolver.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 using Datadog.Trace.Vendors.MessagePack.Formatters; using System; @@ -25,7 +26,7 @@ public static IMessagePackFormatter GetFormatterWithVerify(this IFormatter } catch (TypeInitializationException ex) { -#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +#if NETSTANDARD || NETFRAMEWORK // The fact that we're using static constructors to initialize this is an internal detail. // Rethrow the inner exception if there is one. // Do it carefully so as to not stomp on the original callstack. diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/IMessagePackSerializationCallbackReceiver.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/IMessagePackSerializationCallbackReceiver.cs index 4b9b07f1a..7ab2a404e 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/IMessagePackSerializationCallbackReceiver.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/IMessagePackSerializationCallbackReceiver.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 using System; using System.Collections.Generic; using System.Text; diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/ArrayPool.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/ArrayPool.cs index c921752b0..2384ae48e 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/ArrayPool.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/ArrayPool.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 using System; namespace Datadog.Trace.Vendors.MessagePack.Internal diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/AsymmetricKeyHashTable.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/AsymmetricKeyHashTable.cs new file mode 100644 index 000000000..d1d81eb8b --- /dev/null +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/AsymmetricKeyHashTable.cs @@ -0,0 +1,282 @@ +//------------------------------------------------------------------------------ +// +// This file was automatically generated by the UpdateVendors tool. +//------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 +#if NETSTANDARD || NETFRAMEWORK + +using System; + +namespace Datadog.Trace.Vendors.MessagePack.Internal +{ + // Safe for multiple-read, single-write. + + // Add and Get Key is asymmetric. + + internal interface IAsymmetricEqualityComparer + { + int GetHashCode(TKey1 key1); + int GetHashCode(TKey2 key2); + bool Equals(TKey1 x, TKey1 y); // when used rehash + bool Equals(TKey1 x, TKey2 y); // when used get + } + + internal class StringArraySegmentByteAscymmetricEqualityComparer : IAsymmetricEqualityComparer> + { + static readonly bool Is32Bit = (IntPtr.Size == 4); + + public bool Equals(byte[] x, byte[] y) + { + if (x.Length != y.Length) return false; + + for (int i = 0; i < x.Length; i++) + { + if (x[i] != y[i]) return false; + } + + return true; + } + + public bool Equals(byte[] x, ArraySegment y) + { + return ByteArrayComparer.Equals(y.Array, y.Offset, y.Count, x); + } + + public int GetHashCode(byte[] key1) + { + return GetHashCode(new ArraySegment(key1, 0, key1.Length)); + } + + public int GetHashCode(ArraySegment key2) + { + unchecked + { + if (Is32Bit) + { + return (int)FarmHash.Hash32(key2.Array, key2.Offset, key2.Count); + } + else + { + return (int)FarmHash.Hash64(key2.Array, key2.Offset, key2.Count); + } + } + } + } + + internal sealed class AsymmetricKeyHashTable + { + Entry[] buckets; + int size; // only use in writer lock + + readonly object writerLock = new object(); + readonly float loadFactor; + readonly IAsymmetricEqualityComparer comparer; + + public AsymmetricKeyHashTable(IAsymmetricEqualityComparer comparer) + : this(4, 0.72f, comparer) + { + } + + public AsymmetricKeyHashTable(int capacity, float loadFactor, IAsymmetricEqualityComparer comparer) + { + var tableSize = CalculateCapacity(capacity, loadFactor); + this.buckets = new Entry[tableSize]; + this.loadFactor = loadFactor; + this.comparer = comparer; + } + + public TValue AddOrGet(TKey1 key1, Func valueFactory) + { + TValue v; + TryAddInternal(key1, valueFactory, out v); + return v; + } + + public bool TryAdd(TKey1 key, TValue value) + { + return TryAdd(key, _ => value); // closure capture + } + + public bool TryAdd(TKey1 key, Func valueFactory) + { + TValue _; + return TryAddInternal(key, valueFactory, out _); + } + + bool TryAddInternal(TKey1 key, Func valueFactory, out TValue resultingValue) + { + lock (writerLock) + { + var nextCapacity = CalculateCapacity(size + 1, loadFactor); + + if (buckets.Length < nextCapacity) + { + // rehash + var nextBucket = new Entry[nextCapacity]; + for (int i = 0; i < buckets.Length; i++) + { + var e = buckets[i]; + while (e != null) + { + var newEntry = new Entry { Key = e.Key, Value = e.Value, Hash = e.Hash }; + AddToBuckets(nextBucket, key, newEntry, null, out resultingValue); + e = e.Next; + } + } + + // add entry(if failed to add, only do resize) + var successAdd = AddToBuckets(nextBucket, key, null, valueFactory, out resultingValue); + + // replace field(threadsafe for read) + VolatileWrite(ref buckets, nextBucket); + + if (successAdd) size++; + return successAdd; + } + else + { + // add entry(insert last is thread safe for read) + var successAdd = AddToBuckets(buckets, key, null, valueFactory, out resultingValue); + if (successAdd) size++; + return successAdd; + } + } + } + + bool AddToBuckets(Entry[] buckets, TKey1 newKey, Entry newEntryOrNull, Func valueFactory, out TValue resultingValue) + { + var h = (newEntryOrNull != null) ? newEntryOrNull.Hash : comparer.GetHashCode(newKey); + if (buckets[h & (buckets.Length - 1)] == null) + { + if (newEntryOrNull != null) + { + resultingValue = newEntryOrNull.Value; + VolatileWrite(ref buckets[h & (buckets.Length - 1)], newEntryOrNull); + } + else + { + resultingValue = valueFactory(newKey); + VolatileWrite(ref buckets[h & (buckets.Length - 1)], new Entry { Key = newKey, Value = resultingValue, Hash = h }); + } + } + else + { + var searchLastEntry = buckets[h & (buckets.Length - 1)]; + while (true) + { + if (comparer.Equals(searchLastEntry.Key, newKey)) + { + resultingValue = searchLastEntry.Value; + return false; + } + + if (searchLastEntry.Next == null) + { + if (newEntryOrNull != null) + { + resultingValue = newEntryOrNull.Value; + VolatileWrite(ref searchLastEntry.Next, newEntryOrNull); + } + else + { + resultingValue = valueFactory(newKey); + VolatileWrite(ref searchLastEntry.Next, new Entry { Key = newKey, Value = resultingValue, Hash = h }); + } + break; + } + searchLastEntry = searchLastEntry.Next; + } + } + + return true; + } + + public bool TryGetValue(TKey2 key, out TValue value) + { + var table = buckets; + var hash = comparer.GetHashCode(key); + var entry = table[hash & table.Length - 1]; + + if (entry == null) goto NOT_FOUND; + + if (comparer.Equals(entry.Key, key)) + { + value = entry.Value; + return true; + } + + var next = entry.Next; + while (next != null) + { + if (comparer.Equals(next.Key, key)) + { + value = next.Value; + return true; + } + next = next.Next; + } + + NOT_FOUND: + value = default(TValue); + return false; + } + + static int CalculateCapacity(int collectionSize, float loadFactor) + { + var initialCapacity = (int)(((float)collectionSize) / loadFactor); + var capacity = 1; + while (capacity < initialCapacity) + { + capacity <<= 1; + } + + if (capacity < 8) + { + return 8; + } + + return capacity; + } + + static void VolatileWrite(ref Entry location, Entry value) + { + System.Threading.Volatile.Write(ref location, value); + } + + static void VolatileWrite(ref Entry[] location, Entry[] value) + { + System.Threading.Volatile.Write(ref location, value); + } + + class Entry + { + public TKey1 Key; + public TValue Value; + public int Hash; + public Entry Next; + + // from debugger only + public override string ToString() + { + return "Count:" + Count; + } + + internal int Count + { + get + { + var count = 1; + var n = this; + while (n.Next != null) + { + count++; + n = n.Next; + } + return count; + } + } + } + } +} + +#endif \ No newline at end of file diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/AutomataDictionary.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/AutomataDictionary.cs new file mode 100644 index 000000000..cb9147511 --- /dev/null +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/AutomataDictionary.cs @@ -0,0 +1,929 @@ +//------------------------------------------------------------------------------ +// +// This file was automatically generated by the UpdateVendors tool. +//------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 +using System; +using System.Collections; +using System.Collections.Generic; +using System.Text; +using System.Linq; +using System.Reflection.Emit; +using System.Reflection; + +namespace Datadog.Trace.Vendors.MessagePack.Internal +{ + // Key = long, Value = int for UTF8String Dictionary + + internal class AutomataDictionary : IEnumerable> + { + readonly AutomataNode root; + + public AutomataDictionary() + { + root = new AutomataNode(0); + } + +#if NETSTANDARD || NETFRAMEWORK + public unsafe void Add(string str, int value) + { + var bytes = Encoding.UTF8.GetBytes(str); + fixed (byte* buffer = &bytes[0]) + { + var node = root; + + var p = buffer; + var rest = bytes.Length; + while (rest != 0) + { + var key = AutomataKeyGen.GetKey(ref p, ref rest); + + if (rest == 0) + { + node = node.Add(key, value, str); + } + else + { + node = node.Add(key); + } + } + } + } + + public unsafe bool TryGetValue(byte[] bytes, int offset, int count, out int value) + { + fixed (byte* p = &bytes[0]) + { + var p1 = p; + var node = root; + var rest = count; + + while (rest != 0 && node != null) + { + node = node.SearchNext(ref p1, ref rest); + } + + if (node == null) + { + value = -1; + return false; + } + else + { + value = node.Value; + return true; + } + } + } +#else + // for Unity, use safe only. + + public void Add(string str, int value) + { + var bytes = Encoding.UTF8.GetBytes(str); + var offset = 0; + + var node = root; + + var rest = bytes.Length; + while (rest != 0) + { + var key = AutomataKeyGen.GetKeySafe(bytes, ref offset, ref rest); + + if (rest == 0) + { + node = node.Add(key, value, str); + } + else + { + node = node.Add(key); + } + } + } + +#endif + + + public bool TryGetValueSafe(ArraySegment key, out int value) + { + var node = root; + var bytes = key.Array; + var offset = key.Offset; + var rest = key.Count; + + while (rest != 0 && node != null) + { + node = node.SearchNextSafe(bytes, ref offset, ref rest); + } + + if (node == null) + { + value = -1; + return false; + } + else + { + value = node.Value; + return true; + } + } + + // for debugging + public override string ToString() + { + var sb = new StringBuilder(); + ToStringCore(root.YieldChildren(), sb, 0); + return sb.ToString(); + } + + static void ToStringCore(IEnumerable nexts, StringBuilder sb, int depth) + { + foreach (var item in nexts) + { + if (depth != 0) + { + sb.Append(' ', depth * 2); + } + sb.Append("[" + item.Key + "]"); + if (item.Value != -1) + { + sb.Append("(" + item.originalKey + ")"); + sb.Append(" = "); + sb.Append(item.Value); + } + sb.AppendLine(); + ToStringCore(item.YieldChildren(), sb, depth + 1); + } + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + + public IEnumerator> GetEnumerator() + { + return YieldCore(this.root.YieldChildren()).GetEnumerator(); + } + + static IEnumerable> YieldCore(IEnumerable nexts) + { + foreach (var item in nexts) + { + if (item.Value != -1) yield return new KeyValuePair(item.originalKey, item.Value); + foreach (var x in YieldCore(item.YieldChildren())) yield return x; + } + } + + // IL Emit + +#if !NET_STANDARD_2_0 + + public void EmitMatch(ILGenerator il, LocalBuilder p, LocalBuilder rest, LocalBuilder key, Action> onFound, Action onNotFound) + { + root.EmitSearchNext(il, p, rest, key, onFound, onNotFound); + } + +#endif + + class AutomataNode : IComparable + { + static readonly AutomataNode[] emptyNodes = new AutomataNode[0]; + static readonly ulong[] emptyKeys = new ulong[0]; + + public ulong Key; + public int Value; + public string originalKey; + + AutomataNode[] nexts; + ulong[] nextKeys; + int count; + + public bool HasChildren { get { return count != 0; } } + + public AutomataNode(ulong key) + { + this.Key = key; + this.Value = -1; + this.nexts = emptyNodes; + this.nextKeys = emptyKeys; + this.count = 0; + this.originalKey = null; + } + + public AutomataNode Add(ulong key) + { + var index = Array.BinarySearch(nextKeys, 0, count, key); + if (index < 0) + { + if (nexts.Length == count) + { + Array.Resize(ref nexts, (count == 0) ? 4 : (count * 2)); + Array.Resize(ref nextKeys, (count == 0) ? 4 : (count * 2)); + } + count++; + + var nextNode = new AutomataNode(key); + nexts[count - 1] = nextNode; + nextKeys[count - 1] = key; + Array.Sort(nexts, 0, count); + Array.Sort(nextKeys, 0, count); + return nextNode; + } + else + { + return nexts[index]; + } + } + + public AutomataNode Add(ulong key, int value, string originalKey) + { + var v = Add(key); + v.Value = value; + v.originalKey = originalKey; + return v; + } + +#if NETSTANDARD || NETFRAMEWORK + + public unsafe AutomataNode SearchNext(ref byte* p, ref int rest) + { + var key = AutomataKeyGen.GetKey(ref p, ref rest); + if (count < 4) + { + // linear search + for (int i = 0; i < count; i++) + { + if (nextKeys[i] == key) + { + return nexts[i]; + } + } + } + else + { + // binary search + var index = BinarySearch(nextKeys, 0, count, key); + if (index >= 0) + { + return nexts[index]; + } + } + + return null; + } + +#endif + + public AutomataNode SearchNextSafe(byte[] p, ref int offset, ref int rest) + { + var key = AutomataKeyGen.GetKeySafe(p, ref offset, ref rest); + if (count < 4) + { + // linear search + for (int i = 0; i < count; i++) + { + if (nextKeys[i] == key) + { + return nexts[i]; + } + } + } + else + { + // binary search + var index = BinarySearch(nextKeys, 0, count, key); + if (index >= 0) + { + return nexts[index]; + } + } + + return null; + } + + internal static int BinarySearch(ulong[] array, int index, int length, ulong value) + { + int lo = index; + int hi = index + length - 1; + while (lo <= hi) + { + int i = lo + ((hi - lo) >> 1); + + var arrayValue = array[i]; + int order; + if (arrayValue < value) order = -1; + else if (arrayValue > value) order = 1; + else order = 0; + + if (order == 0) return i; + if (order < 0) + { + lo = i + 1; + } + else + { + hi = i - 1; + } + } + + return ~lo; + } + + public int CompareTo(AutomataNode other) + { + return this.Key.CompareTo(other.Key); + } + + public IEnumerable YieldChildren() + { + for (int i = 0; i < count; i++) + { + yield return nexts[i]; + } + } + +#if !NET_STANDARD_2_0 + + // SearchNext(ref byte* p, ref int rest, ref ulong key) + public void EmitSearchNext(ILGenerator il, LocalBuilder p, LocalBuilder rest, LocalBuilder key, Action> onFound, Action onNotFound) + { + // key = AutomataKeyGen.GetKey(ref p, ref rest); + il.EmitLdloca(p); + il.EmitLdloca(rest); +#if NETSTANDARD || NETFRAMEWORK + il.EmitCall(AutomataKeyGen.GetKeyMethod); +#else + il.EmitCall(AutomataKeyGen.GetGetKeyMethod()); +#endif + il.EmitStloc(key); + + // match children. + EmitSearchNextCore(il, p, rest, key, onFound, onNotFound, nexts, count); + } + + static void EmitSearchNextCore(ILGenerator il, LocalBuilder p, LocalBuilder rest, LocalBuilder key, Action> onFound, Action onNotFound, AutomataNode[] nexts, int count) + { + if (count < 4) + { + // linear-search + var valueExists = nexts.Take(count).Where(x => x.Value != -1).ToArray(); + var childrenExists = nexts.Take(count).Where(x => x.HasChildren).ToArray(); + var gotoSearchNext = il.DefineLabel(); + var gotoNotFound = il.DefineLabel(); + + { + il.EmitLdloc(rest); + if (childrenExists.Length != 0 && valueExists.Length == 0) + { + + il.Emit(OpCodes.Brfalse, gotoNotFound); // if(rest == 0) + } + else + { + il.Emit(OpCodes.Brtrue, gotoSearchNext); // if(rest != 0) + } + } + { + var ifValueNexts = Enumerable.Range(0, Math.Max(valueExists.Length - 1, 0)).Select(_ => il.DefineLabel()).ToArray(); + for (int i = 0; i < valueExists.Length; i++) + { + var notFoundLabel = il.DefineLabel(); + if (i != 0) + { + il.MarkLabel(ifValueNexts[i - 1]); + } + + il.EmitLdloc(key); + il.EmitULong(valueExists[i].Key); + il.Emit(OpCodes.Bne_Un, notFoundLabel); + // found + onFound(new KeyValuePair(valueExists[i].originalKey, valueExists[i].Value)); + + // notfound + il.MarkLabel(notFoundLabel); + if (i != valueExists.Length - 1) + { + il.Emit(OpCodes.Br, ifValueNexts[i]); + } + else + { + onNotFound(); + } + } + } + + il.MarkLabel(gotoSearchNext); + var ifRecNext = Enumerable.Range(0, Math.Max(childrenExists.Length - 1, 0)).Select(_ => il.DefineLabel()).ToArray(); + for (int i = 0; i < childrenExists.Length; i++) + { + var notFoundLabel = il.DefineLabel(); + if (i != 0) + { + il.MarkLabel(ifRecNext[i - 1]); + } + + il.EmitLdloc(key); + il.EmitULong(childrenExists[i].Key); + il.Emit(OpCodes.Bne_Un, notFoundLabel); + // found + childrenExists[i].EmitSearchNext(il, p, rest, key, onFound, onNotFound); + // notfound + il.MarkLabel(notFoundLabel); + if (i != childrenExists.Length - 1) + { + il.Emit(OpCodes.Br, ifRecNext[i]); + } + else + { + onNotFound(); + } + } + + il.MarkLabel(gotoNotFound); + onNotFound(); + } + else + { + // binary-search + var midline = count / 2; + var mid = nexts[midline].Key; + var l = nexts.Take(count).Take(midline).ToArray(); + var r = nexts.Take(count).Skip(midline).ToArray(); + + var gotoRight = il.DefineLabel(); + + // if(key < mid) + il.EmitLdloc(key); + il.EmitULong(mid); + il.Emit(OpCodes.Bge, gotoRight); + EmitSearchNextCore(il, p, rest, key, onFound, onNotFound, l, l.Length); + + // else + il.MarkLabel(gotoRight); + EmitSearchNextCore(il, p, rest, key, onFound, onNotFound, r, r.Length); + } + } + +#endif + } + } + + internal static class AutomataKeyGen + { + internal delegate ulong PointerDelegate(ref T p, ref int rest); + +#if NETSTANDARD || NETFRAMEWORK + public static readonly MethodInfo GetKeyMethod = typeof(AutomataKeyGen).GetRuntimeMethod("GetKey", new[] { typeof(byte).MakePointerType().MakeByRefType(), typeof(int).MakeByRefType() }); +#endif + +#if !NETSTANDARD + +#if !NET_STANDARD_2_0 + + static MethodInfo dynamicGetKeyMethod; + static readonly object gate = new object(); + static DynamicAssembly dynamicAssembly; + + public static MethodInfo GetGetKeyMethod() + { + if (dynamicGetKeyMethod == null) + { + lock (gate) + { + if (dynamicGetKeyMethod == null) + { + dynamicAssembly = new DynamicAssembly("AutomataKeyGenHelper"); + var helperType = dynamicAssembly.DefineType("AutomataKeyGen", TypeAttributes.Class | TypeAttributes.Public | TypeAttributes.Sealed | TypeAttributes.Abstract, null); + + var dm = helperType.DefineMethod("GetKey", MethodAttributes.Public | MethodAttributes.Static | MethodAttributes.HideBySig, typeof(ulong), new[] { typeof(byte).MakePointerType().MakeByRefType(), typeof(int).MakeByRefType() }); + + var il = dm.GetILGenerator(); + + il.DeclareLocal(typeof(int)); // var readSize + il.DeclareLocal(typeof(ulong)); // var key = + il.DeclareLocal(typeof(int)); // var _local = + + var elseLabel = il.DefineLabel(); + var endLabel = il.DefineLabel(); + var case0 = il.DefineLabel(); + var case1 = il.DefineLabel(); + var case2 = il.DefineLabel(); + var case3 = il.DefineLabel(); + var case4 = il.DefineLabel(); + var case5 = il.DefineLabel(); + var case6 = il.DefineLabel(); + var case7 = il.DefineLabel(); + + il.Emit(OpCodes.Ldarg_1); + il.Emit(OpCodes.Ldind_I4); + il.Emit(OpCodes.Ldc_I4_8); + il.Emit(OpCodes.Blt_S, elseLabel); + il.Emit(OpCodes.Ldarg_0); + il.Emit(OpCodes.Ldind_I); + il.Emit(OpCodes.Ldind_I8); + il.Emit(OpCodes.Stloc_1); + il.Emit(OpCodes.Ldc_I4_8); + il.Emit(OpCodes.Stloc_0); + il.Emit(OpCodes.Br, endLabel); + + il.MarkLabel(elseLabel); + il.Emit(OpCodes.Ldarg_1); + il.Emit(OpCodes.Ldind_I4); + il.Emit(OpCodes.Stloc_2); + il.Emit(OpCodes.Ldloc_2); + il.Emit(OpCodes.Switch, new[] { case0, case1, case2, case3, case4, case5, case6, case7 }); + il.Emit(OpCodes.Br, case0); // default + + il.MarkLabel(case1); + il.Emit(OpCodes.Ldarg_0); + il.Emit(OpCodes.Ldind_I); + il.Emit(OpCodes.Ldind_U1); + il.Emit(OpCodes.Conv_U8); + il.Emit(OpCodes.Stloc_1); + il.Emit(OpCodes.Ldc_I4_1); + il.Emit(OpCodes.Stloc_0); + il.Emit(OpCodes.Br, endLabel); + + il.MarkLabel(case2); + il.Emit(OpCodes.Ldarg_0); + il.Emit(OpCodes.Ldind_I); + il.Emit(OpCodes.Ldind_U2); + il.Emit(OpCodes.Conv_U8); + il.Emit(OpCodes.Stloc_1); + il.Emit(OpCodes.Ldc_I4_2); + il.Emit(OpCodes.Stloc_0); + il.Emit(OpCodes.Br, endLabel); + + il.MarkLabel(case3); + il.DeclareLocal(typeof(ushort)); // _3 + il.Emit(OpCodes.Ldarg_0); + il.Emit(OpCodes.Ldind_I); + il.Emit(OpCodes.Ldind_U1); + il.Emit(OpCodes.Ldarg_0); + il.Emit(OpCodes.Ldind_I); + il.Emit(OpCodes.Ldc_I4_1); + il.Emit(OpCodes.Add); + il.Emit(OpCodes.Ldind_U2); + il.Emit(OpCodes.Stloc_3); + il.Emit(OpCodes.Conv_U8); + il.Emit(OpCodes.Ldloc_3); + il.Emit(OpCodes.Conv_U8); + il.Emit(OpCodes.Ldc_I4_8); + il.Emit(OpCodes.Shl); + il.Emit(OpCodes.Or); + il.Emit(OpCodes.Stloc_1); + il.Emit(OpCodes.Ldc_I4_3); + il.Emit(OpCodes.Stloc_0); + il.Emit(OpCodes.Br, endLabel); + + il.MarkLabel(case4); + il.Emit(OpCodes.Ldarg_0); + il.Emit(OpCodes.Ldind_I); + il.Emit(OpCodes.Ldind_U4); + il.Emit(OpCodes.Conv_U8); + il.Emit(OpCodes.Stloc_1); + il.Emit(OpCodes.Ldc_I4_4); + il.Emit(OpCodes.Stloc_0); + il.Emit(OpCodes.Br, endLabel); + + il.MarkLabel(case5); + il.DeclareLocal(typeof(uint)); // _4 + il.Emit(OpCodes.Ldarg_0); + il.Emit(OpCodes.Ldind_I); + il.Emit(OpCodes.Ldind_U1); + il.Emit(OpCodes.Ldarg_0); + il.Emit(OpCodes.Ldind_I); + il.Emit(OpCodes.Ldc_I4_1); + il.Emit(OpCodes.Add); + il.Emit(OpCodes.Ldind_U4); + il.Emit(OpCodes.Stloc_S, 4); + il.Emit(OpCodes.Conv_U8); + il.Emit(OpCodes.Ldloc_S, 4); + il.Emit(OpCodes.Conv_U8); + il.Emit(OpCodes.Ldc_I4_8); + il.Emit(OpCodes.Shl); + il.Emit(OpCodes.Or); + il.Emit(OpCodes.Stloc_1); + il.Emit(OpCodes.Ldc_I4_5); + il.Emit(OpCodes.Stloc_0); + il.Emit(OpCodes.Br, endLabel); + + il.MarkLabel(case6); + il.DeclareLocal(typeof(ulong)); // _5 + il.Emit(OpCodes.Ldarg_0); + il.Emit(OpCodes.Ldind_I); + il.Emit(OpCodes.Ldind_U2); + il.Emit(OpCodes.Conv_U8); // [x] + il.Emit(OpCodes.Ldarg_0); + il.Emit(OpCodes.Ldind_I); + il.Emit(OpCodes.Ldc_I4_2); + il.Emit(OpCodes.Add); // [x, y] + il.Emit(OpCodes.Ldind_U4); + il.Emit(OpCodes.Conv_U8); + il.Emit(OpCodes.Stloc_S, 5); // [x] + il.Emit(OpCodes.Ldloc_S, 5); + il.Emit(OpCodes.Ldc_I4_S, 16); + il.Emit(OpCodes.Shl); + il.Emit(OpCodes.Or); + il.Emit(OpCodes.Stloc_1); + il.Emit(OpCodes.Ldc_I4_6); + il.Emit(OpCodes.Stloc_0); + il.Emit(OpCodes.Br, endLabel); + + il.MarkLabel(case7); + il.DeclareLocal(typeof(ushort)); // _6 + il.DeclareLocal(typeof(uint)); // _7 + il.Emit(OpCodes.Ldarg_0); + il.Emit(OpCodes.Ldind_I); + il.Emit(OpCodes.Ldind_U1); + il.Emit(OpCodes.Ldarg_0); + il.Emit(OpCodes.Ldind_I); + il.Emit(OpCodes.Ldc_I4_1); + il.Emit(OpCodes.Add); + il.Emit(OpCodes.Ldind_U2); + il.Emit(OpCodes.Stloc_S, 6); + il.Emit(OpCodes.Ldarg_0); + il.Emit(OpCodes.Ldind_I); + il.Emit(OpCodes.Ldc_I4_3); + il.Emit(OpCodes.Add); + il.Emit(OpCodes.Ldind_U4); + il.Emit(OpCodes.Stloc_S, 7); + il.Emit(OpCodes.Conv_U8); + il.Emit(OpCodes.Ldloc_S, 6); + il.Emit(OpCodes.Conv_U8); + il.Emit(OpCodes.Ldc_I4_8); + il.Emit(OpCodes.Shl); + il.Emit(OpCodes.Or); + il.Emit(OpCodes.Ldloc_S, 7); + il.Emit(OpCodes.Conv_U8); + il.Emit(OpCodes.Ldc_I4_S, 24); + il.Emit(OpCodes.Shl); + il.Emit(OpCodes.Or); + il.Emit(OpCodes.Stloc_1); + il.Emit(OpCodes.Ldc_I4_7); + il.Emit(OpCodes.Stloc_0); + il.Emit(OpCodes.Br, endLabel); + + il.MarkLabel(case0); + il.Emit(OpCodes.Ldstr, "Not Supported Length"); + il.Emit(OpCodes.Newobj, typeof(InvalidOperationException).GetConstructor(new[] { typeof(string) })); + il.Emit(OpCodes.Throw); + + il.MarkLabel(endLabel); + il.Emit(OpCodes.Ldarg_0); + il.Emit(OpCodes.Ldarg_0); + il.Emit(OpCodes.Ldind_I); + il.Emit(OpCodes.Ldloc_0); + il.Emit(OpCodes.Add); + il.Emit(OpCodes.Stind_I); + il.Emit(OpCodes.Ldarg_1); + il.Emit(OpCodes.Ldarg_1); + il.Emit(OpCodes.Ldind_I4); + il.Emit(OpCodes.Ldloc_0); + il.Emit(OpCodes.Sub); + il.Emit(OpCodes.Stind_I4); + il.Emit(OpCodes.Ldloc_1); + il.Emit(OpCodes.Ret); + + var genereatedType = helperType.CreateTypeInfo().AsType(); + dynamicGetKeyMethod = genereatedType.GetMethods().First(); + } + } + } + + return dynamicGetKeyMethod; + } + +#endif + +#endif + +#if NETSTANDARD || NETFRAMEWORK + + public static unsafe ulong GetKey(ref byte* p, ref int rest) + { + int readSize; + ulong key; + + unchecked + { + if (rest >= 8) + { + key = *(ulong*)p; + readSize = 8; + } + else + { + switch (rest) + { + case 1: + { + key = *(byte*)p; + readSize = 1; + break; + } + case 2: + { + key = *(ushort*)p; + readSize = 2; + break; + } + case 3: + { + var a = *p; + var b = *(ushort*)(p + 1); + key = ((ulong)a | (ulong)b << 8); + readSize = 3; + break; + } + case 4: + { + key = *(uint*)p; + readSize = 4; + break; + } + case 5: + { + var a = *p; + var b = *(uint*)(p + 1); + key = ((ulong)a | (ulong)b << 8); + readSize = 5; + break; + } + case 6: + { + ulong a = *(ushort*)p; + ulong b = *(uint*)(p + 2); + key = (a | (b << 16)); + readSize = 6; + break; + } + case 7: + { + var a = *(byte*)p; + var b = *(ushort*)(p + 1); + var c = *(uint*)(p + 3); + key = ((ulong)a | (ulong)b << 8 | (ulong)c << 24); + readSize = 7; + break; + } + default: + throw new InvalidOperationException("Not Supported Length"); + } + } + + p += readSize; + rest -= readSize; + return key; + } + } + +#endif + + public static ulong GetKeySafe(byte[] bytes, ref int offset, ref int rest) + { + int readSize; + ulong key; + + if (BitConverter.IsLittleEndian) + { + unchecked + { + if (rest >= 8) + { + key = (ulong)bytes[offset] << 0 | (ulong)bytes[offset + 1] << 8 | (ulong)bytes[offset + 2] << 16 | (ulong)bytes[offset + 3] << 24 + | (ulong)bytes[offset + 4] << 32 | (ulong)bytes[offset + 5] << 40 | (ulong)bytes[offset + 6] << 48 | (ulong)bytes[offset + 7] << 56; + readSize = 8; + } + else + { + switch (rest) + { + case 1: + { + key = bytes[offset]; + readSize = 1; + break; + } + case 2: + { + key = (ulong)bytes[offset] << 0 | (ulong)bytes[offset + 1] << 8; + readSize = 2; + break; + } + case 3: + { + key = (ulong)bytes[offset] << 0 | (ulong)bytes[offset + 1] << 8 | (ulong)bytes[offset + 2] << 16; + readSize = 3; + break; + } + case 4: + { + key = (ulong)bytes[offset] << 0 | (ulong)bytes[offset + 1] << 8 | (ulong)bytes[offset + 2] << 16 | (ulong)bytes[offset + 3] << 24; + readSize = 4; + break; + } + case 5: + { + key = (ulong)bytes[offset] << 0 | (ulong)bytes[offset + 1] << 8 | (ulong)bytes[offset + 2] << 16 | (ulong)bytes[offset + 3] << 24 + | (ulong)bytes[offset + 4] << 32; + readSize = 5; + break; + } + case 6: + { + key = (ulong)bytes[offset] << 0 | (ulong)bytes[offset + 1] << 8 | (ulong)bytes[offset + 2] << 16 | (ulong)bytes[offset + 3] << 24 + | (ulong)bytes[offset + 4] << 32 | (ulong)bytes[offset + 5] << 40; + readSize = 6; + break; + } + case 7: + { + key = (ulong)bytes[offset] << 0 | (ulong)bytes[offset + 1] << 8 | (ulong)bytes[offset + 2] << 16 | (ulong)bytes[offset + 3] << 24 + | (ulong)bytes[offset + 4] << 32 | (ulong)bytes[offset + 5] << 40 | (ulong)bytes[offset + 6] << 48; + readSize = 7; + break; + } + default: + throw new InvalidOperationException("Not Supported Length"); + } + } + + offset += readSize; + rest -= readSize; + return key; + } + } + else + { + unchecked + { + if (rest >= 8) + { + key = (ulong)bytes[offset] << 56 | (ulong)bytes[offset + 1] << 48 | (ulong)bytes[offset + 2] << 40 | (ulong)bytes[offset + 3] << 32 + | (ulong)bytes[offset + 4] << 24 | (ulong)bytes[offset + 5] << 16 | (ulong)bytes[offset + 6] << 8 | (ulong)bytes[offset + 7]; + readSize = 8; + } + else + { + switch (rest) + { + case 1: + { + key = bytes[offset]; + readSize = 1; + break; + } + case 2: + { + key = (ulong)bytes[offset] << 8 | (ulong)bytes[offset + 1] << 0; + readSize = 2; + break; + } + case 3: + { + key = (ulong)bytes[offset] << 16 | (ulong)bytes[offset + 1] << 8 | (ulong)bytes[offset + 2] << 0; + readSize = 3; + break; + } + case 4: + { + key = (ulong)bytes[offset] << 24 | (ulong)bytes[offset + 1] << 16 | (ulong)bytes[offset + 2] << 8 | (ulong)bytes[offset + 3] << 0; + readSize = 4; + break; + } + case 5: + { + key = (ulong)bytes[offset] << 32 | (ulong)bytes[offset + 1] << 24 | (ulong)bytes[offset + 2] << 16 | (ulong)bytes[offset + 3] << 8 + | (ulong)bytes[offset + 4] << 0; + readSize = 5; + break; + } + case 6: + { + key = (ulong)bytes[offset] << 40 | (ulong)bytes[offset + 1] << 32 | (ulong)bytes[offset + 2] << 24 | (ulong)bytes[offset + 3] << 16 + | (ulong)bytes[offset + 4] << 8 | (ulong)bytes[offset + 5] << 0; + readSize = 6; + break; + } + case 7: + { + key = (ulong)bytes[offset] << 48 | (ulong)bytes[offset + 1] << 40 | (ulong)bytes[offset + 2] << 32 | (ulong)bytes[offset + 3] << 24 + | (ulong)bytes[offset + 4] << 16 | (ulong)bytes[offset + 5] << 8 | (ulong)bytes[offset + 6] << 0; + readSize = 7; + break; + } + default: + throw new InvalidOperationException("Not Supported Length"); + } + } + + offset += readSize; + rest -= readSize; + return key; + } + } + } + } +} \ No newline at end of file diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/ByteArrayComparer.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/ByteArrayComparer.cs index 9fb71dc13..e99b2f99e 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/ByteArrayComparer.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/ByteArrayComparer.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 using System; using System.Collections.Generic; using System.Text; @@ -12,7 +13,7 @@ internal static class ByteArrayComparer { #if ENABLE_UNSAFE_MSGPACK -#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +#if NETSTANDARD || NETFRAMEWORK static readonly bool Is32Bit = (IntPtr.Size == 4); diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/ByteArrayStringHashTable.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/ByteArrayStringHashTable.cs index fb60954a5..42e7bb297 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/ByteArrayStringHashTable.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/ByteArrayStringHashTable.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 using System; using System.Collections; using System.Collections.Generic; @@ -88,7 +89,7 @@ public bool TryGetValue(ArraySegment key, out int value) if (entry == null) goto NOT_FOUND; { -#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +#if NETSTANDARD || NETFRAMEWORK ref var v = ref entry[0]; #else var v = entry[0]; @@ -102,7 +103,7 @@ public bool TryGetValue(ArraySegment key, out int value) for (int i = 1; i < entry.Length; i++) { -#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +#if NETSTANDARD || NETFRAMEWORK ref var v = ref entry[i]; #else var v = entry[i]; @@ -119,7 +120,7 @@ public bool TryGetValue(ArraySegment key, out int value) return false; } -#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +#if NETSTANDARD || NETFRAMEWORK static readonly bool Is32Bit = (IntPtr.Size == 4); #endif @@ -128,6 +129,21 @@ public bool TryGetValue(ArraySegment key, out int value) #endif static ulong ByteArrayGetHashCode(byte[] x, int offset, int count) { +#if NETSTANDARD || NETFRAMEWORK + // FarmHash https://github.com/google/farmhash + if (x == null) return 0; + + if (Is32Bit) + { + return (ulong)FarmHash.Hash32(x, offset, count); + } + else + { + return FarmHash.Hash64(x, offset, count); + } + +#else + // FNV1-1a 32bit https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function uint hash = 0; if (x != null) @@ -142,6 +158,8 @@ static ulong ByteArrayGetHashCode(byte[] x, int offset, int count) } return (ulong)hash; + +#endif } static int CalculateCapacity(int collectionSize, float loadFactor) diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/DynamicAssembly.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/DynamicAssembly.cs new file mode 100644 index 000000000..145ff525a --- /dev/null +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/DynamicAssembly.cs @@ -0,0 +1,84 @@ +//------------------------------------------------------------------------------ +// +// This file was automatically generated by the UpdateVendors tool. +//------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 +#if !UNITY_WSA +#if !NET_STANDARD_2_0 + +using System; +using System.Reflection; +using System.Reflection.Emit; + +namespace Datadog.Trace.Vendors.MessagePack.Internal +{ + internal class DynamicAssembly + { +#if NETFRAMEWORK + readonly string moduleName; +#endif + readonly AssemblyBuilder assemblyBuilder; + readonly ModuleBuilder moduleBuilder; + + // don't expose ModuleBuilder + // public ModuleBuilder ModuleBuilder { get { return moduleBuilder; } } + + readonly object gate = new object(); + + public DynamicAssembly(string moduleName) + { +#if NETFRAMEWORK + this.moduleName = moduleName; + this.assemblyBuilder = System.AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName(moduleName), AssemblyBuilderAccess.RunAndSave); + this.moduleBuilder = assemblyBuilder.DefineDynamicModule(moduleName, moduleName + ".dll"); +#else +#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP + this.assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName(moduleName), AssemblyBuilderAccess.Run); +#else + this.assemblyBuilder = System.AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName(moduleName), AssemblyBuilderAccess.Run); +#endif + + this.moduleBuilder = assemblyBuilder.DefineDynamicModule(moduleName); +#endif + } + + // requires lock on mono environment. see: https://github.com/neuecc/MessagePack-CSharp/issues/161 + + public TypeBuilder DefineType(string name, TypeAttributes attr) + { + lock (gate) + { + return moduleBuilder.DefineType(name, attr); + } + } + + public TypeBuilder DefineType(string name, TypeAttributes attr, Type parent) + { + lock (gate) + { + return moduleBuilder.DefineType(name, attr, parent); + } + } + + public TypeBuilder DefineType(string name, TypeAttributes attr, Type parent, Type[] interfaces) + { + lock (gate) + { + return moduleBuilder.DefineType(name, attr, parent, interfaces); + } + } + +#if NETFRAMEWORK + + public AssemblyBuilder Save() + { + assemblyBuilder.Save(moduleName + ".dll"); + return assemblyBuilder; + } + +#endif + } +} + +#endif +#endif \ No newline at end of file diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/ExpressionUtility.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/ExpressionUtility.cs index fec99c955..e256ed28b 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/ExpressionUtility.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/ExpressionUtility.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 using System; using System.Linq.Expressions; using System.Reflection; diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/FarmHash.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/FarmHash.cs new file mode 100644 index 000000000..16c850426 --- /dev/null +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/FarmHash.cs @@ -0,0 +1,609 @@ +//------------------------------------------------------------------------------ +// +// This file was automatically generated by the UpdateVendors tool. +//------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 +#if NETSTANDARD || NETFRAMEWORK + +using System.Runtime.CompilerServices; + +namespace Datadog.Trace.Vendors.MessagePack.Internal +{ + internal static class FarmHash + { + // entry point of 32bit + + #region Hash32 + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe uint Hash32(byte[] bytes, int offset, int count) + { + if (count <= 4) + { + return Hash32Len0to4(bytes, offset, (uint)count); + } + + fixed (byte* p = &bytes[offset]) + { + return Hash32(p, (uint)count); + } + } + + // port of farmhash.cc, 32bit only + + // Magic numbers for 32-bit hashing. Copied from Murmur3. + const uint c1 = 0xcc9e2d51; + const uint c2 = 0x1b873593; + + static unsafe uint Fetch32(byte* p) + { + return *(uint*)p; + } + + static uint Rotate32(uint val, int shift) + { + return shift == 0 ? val : ((val >> shift) | (val << (32 - shift))); + } + + // A 32-bit to 32-bit integer hash copied from Murmur3. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + static uint fmix(uint h) + { + unchecked + { + h ^= h >> 16; + h *= 0x85ebca6b; + h ^= h >> 13; + h *= 0xc2b2ae35; + h ^= h >> 16; + return h; + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + static uint Mur(uint a, uint h) + { + unchecked + { + // Helper from Murmur3 for combining two 32-bit values. + a *= c1; + a = Rotate32(a, 17); + a *= c2; + h ^= a; + h = Rotate32(h, 19); + return h * 5 + 0xe6546b64; + } + } + + // 0-4 + [MethodImpl(MethodImplOptions.AggressiveInlining)] + static unsafe uint Hash32Len0to4(byte[] s, int offset, uint len) + { + unchecked + { + uint b = 0; + uint c = 9; + var max = offset + len; + for (int i = offset; i < max; i++) + { + b = b * c1 + s[i]; + c ^= b; + } + return fmix(Mur(b, Mur(len, c))); + } + } + + // 5-12 + [MethodImpl(MethodImplOptions.AggressiveInlining)] + static unsafe uint Hash32Len5to12(byte* s, uint len) + { + unchecked + { + uint a = len, b = len * 5, c = 9, d = b; + a += Fetch32(s); + b += Fetch32(s + len - 4); + c += Fetch32(s + ((len >> 1) & 4)); + return fmix(Mur(c, Mur(b, Mur(a, d)))); + } + } + + // 13-24 + [MethodImpl(MethodImplOptions.AggressiveInlining)] + static unsafe uint Hash32Len13to24(byte* s, uint len) + { + unchecked + { + uint a = Fetch32(s - 4 + (len >> 1)); + uint b = Fetch32(s + 4); + uint c = Fetch32(s + len - 8); + uint d = Fetch32(s + (len >> 1)); + uint e = Fetch32(s); + uint f = Fetch32(s + len - 4); + uint h = d * c1 + len; + a = Rotate32(a, 12) + f; + h = Mur(c, h) + a; + a = Rotate32(a, 3) + c; + h = Mur(e, h) + a; + a = Rotate32(a + f, 12) + d; + h = Mur(b, h) + a; + return fmix(h); + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + static unsafe uint Hash32(byte* s, uint len) + { + if (len <= 24) + { + return len <= 12 ? Hash32Len5to12(s, len) : Hash32Len13to24(s, len); + } + + unchecked + { + // len > 24 + uint h = len, g = c1 * len, f = g; + uint a0 = Rotate32(Fetch32(s + len - 4) * c1, 17) * c2; + uint a1 = Rotate32(Fetch32(s + len - 8) * c1, 17) * c2; + uint a2 = Rotate32(Fetch32(s + len - 16) * c1, 17) * c2; + uint a3 = Rotate32(Fetch32(s + len - 12) * c1, 17) * c2; + uint a4 = Rotate32(Fetch32(s + len - 20) * c1, 17) * c2; + h ^= a0; + h = Rotate32(h, 19); + h = h * 5 + 0xe6546b64; + h ^= a2; + h = Rotate32(h, 19); + h = h * 5 + 0xe6546b64; + g ^= a1; + g = Rotate32(g, 19); + g = g * 5 + 0xe6546b64; + g ^= a3; + g = Rotate32(g, 19); + g = g * 5 + 0xe6546b64; + f += a4; + f = Rotate32(f, 19) + 113; + uint iters = (len - 1) / 20; + do + { + uint a = Fetch32(s); + uint b = Fetch32(s + 4); + uint c = Fetch32(s + 8); + uint d = Fetch32(s + 12); + uint e = Fetch32(s + 16); + h += a; + g += b; + f += c; + h = Mur(d, h) + e; + g = Mur(c, g) + a; + f = Mur(b + e * c1, f) + d; + f += g; + g += f; + s += 20; + } while (--iters != 0); + g = Rotate32(g, 11) * c1; + g = Rotate32(g, 17) * c1; + f = Rotate32(f, 11) * c1; + f = Rotate32(f, 17) * c1; + h = Rotate32(h + g, 19); + h = h * 5 + 0xe6546b64; + h = Rotate32(h, 17) * c1; + h = Rotate32(h + f, 19); + h = h * 5 + 0xe6546b64; + h = Rotate32(h, 17) * c1; + return h; + } + } + + #endregion + + #region hash64 + + // entry point + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe ulong Hash64(byte[] bytes, int offset, int count) + { + fixed (byte* p = &bytes[offset]) + { + return Hash64(p, (uint)count); + } + } + + // port from farmhash.cc + + struct pair + { + public ulong first; + public ulong second; + + public pair(ulong first, ulong second) + { + this.first = first; + this.second = second; + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + static pair make_pair(ulong first, ulong second) + { + return new pair(first, second); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + static void swap(ref ulong x, ref ulong z) + { + var temp = z; + z = x; + x = temp; + } + + // Some primes between 2^63 and 2^64 for various uses. + const ulong k0 = 0xc3a5c85c97cb3127UL; + const ulong k1 = 0xb492b66fbe98f273UL; + const ulong k2 = 0x9ae16a3b2f90404fUL; + + static unsafe ulong Fetch64(byte* p) + { + return *(ulong*)p; + } + + static ulong Rotate64(ulong val, int shift) + { + return shift == 0 ? val : (val >> shift) | (val << (64 - shift)); + } + + // farmhashna.cc + [MethodImpl(MethodImplOptions.AggressiveInlining)] + static ulong ShiftMix(ulong val) + { + return val ^ (val >> 47); + } + + // farmhashna.cc + [MethodImpl(MethodImplOptions.AggressiveInlining)] + static ulong HashLen16(ulong u, ulong v, ulong mul) + { + unchecked + { + // Murmur-inspired hashing. + ulong a = (u ^ v) * mul; + a ^= a >> 47; + ulong b = (v ^ a) * mul; + b ^= b >> 47; + b *= mul; + return b; + } + } + + // farmhashxo.cc + [MethodImpl(MethodImplOptions.AggressiveInlining)] + static unsafe ulong Hash64(byte* s, uint len) + { + if (len <= 16) + { + // farmhashna:: + return HashLen0to16(s, len); + } + + if (len <= 32) + { + // farmhashna:: + return HashLen17to32(s, len); + } + + if (len <= 64) + { + return HashLen33to64(s, len); + } + + if (len <= 96) + { + return HashLen65to96(s, len); + } + + if (len <= 256) + { + // farmhashna:: + return Hash64NA(s, len); + } + + // farmhashuo:: + return Hash64UO(s, len); + } + + // 0-16 farmhashna.cc + [MethodImpl(MethodImplOptions.AggressiveInlining)] + static unsafe ulong HashLen0to16(byte* s, uint len) + { + unchecked + { + if (len >= 8) + { + ulong mul = k2 + len * 2; + ulong a = Fetch64(s) + k2; + ulong b = Fetch64(s + len - 8); + ulong c = Rotate64(b, 37) * mul + a; + ulong d = (Rotate64(a, 25) + b) * mul; + return HashLen16(c, d, mul); + } + if (len >= 4) + { + ulong mul = k2 + len * 2; + ulong a = Fetch32(s); + return HashLen16(len + (a << 3), Fetch32(s + len - 4), mul); + } + if (len > 0) + { + ushort a = s[0]; + ushort b = s[len >> 1]; + ushort c = s[len - 1]; + uint y = a + ((uint)b << 8); + uint z = len + ((uint)c << 2); + return ShiftMix(y * k2 ^ z * k0) * k2; + } + return k2; + } + } + + // 17-32 farmhashna.cc + [MethodImpl(MethodImplOptions.AggressiveInlining)] + static unsafe ulong HashLen17to32(byte* s, uint len) + { + unchecked + { + ulong mul = k2 + len * 2; + ulong a = Fetch64(s) * k1; + ulong b = Fetch64(s + 8); + ulong c = Fetch64(s + len - 8) * mul; + ulong d = Fetch64(s + len - 16) * k2; + return HashLen16(Rotate64(a + b, 43) + Rotate64(c, 30) + d, + a + Rotate64(b + k2, 18) + c, mul); + } + } + + // farmhashxo.cc + [MethodImpl(MethodImplOptions.AggressiveInlining)] + static unsafe ulong H32(byte* s, uint len, ulong mul, ulong seed0 = 0, ulong seed1 = 0) + { + unchecked + { + ulong a = Fetch64(s) * k1; + ulong b = Fetch64(s + 8); + ulong c = Fetch64(s + len - 8) * mul; + ulong d = Fetch64(s + len - 16) * k2; + ulong u = Rotate64(a + b, 43) + Rotate64(c, 30) + d + seed0; + ulong v = a + Rotate64(b + k2, 18) + c + seed1; + a = ShiftMix((u ^ v) * mul); + b = ShiftMix((v ^ a) * mul); + return b; + } + } + + // 33-64 farmhashxo.cc + [MethodImpl(MethodImplOptions.AggressiveInlining)] + static unsafe ulong HashLen33to64(byte* s, uint len) + { + const ulong mul0 = k2 - 30; + + unchecked + { + ulong mul1 = k2 - 30 + 2 * len; + ulong h0 = H32(s, 32, mul0); + ulong h1 = H32(s + len - 32, 32, mul1); + return (h1 * mul1 + h0) * mul1; + } + } + + // 65-96 farmhashxo.cc + [MethodImpl(MethodImplOptions.AggressiveInlining)] + static unsafe ulong HashLen65to96(byte* s, uint len) + { + const ulong mul0 = k2 - 114; + + unchecked + { + ulong mul1 = k2 - 114 + 2 * len; + ulong h0 = H32(s, 32, mul0); + ulong h1 = H32(s + 32, 32, mul1); + ulong h2 = H32(s + len - 32, 32, mul1, h0, h1); + return (h2 * 9 + (h0 >> 17) + (h1 >> 21)) * mul1; + } + } + + // farmhashna.cc + // Return a 16-byte hash for 48 bytes. Quick and dirty. + // Callers do best to use "random-looking" values for a and b. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + static unsafe pair WeakHashLen32WithSeeds(ulong w, ulong x, ulong y, ulong z, ulong a, ulong b) + { + unchecked + { + a += w; + b = Rotate64(b + a + z, 21); + ulong c = a; + a += x; + a += y; + b += Rotate64(a, 44); + return make_pair(a + z, b + c); + } + } + + // farmhashna.cc + // Return a 16-byte hash for s[0] ... s[31], a, and b. Quick and dirty. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + static unsafe pair WeakHashLen32WithSeeds(byte* s, ulong a, ulong b) + { + return WeakHashLen32WithSeeds(Fetch64(s), + Fetch64(s + 8), + Fetch64(s + 16), + Fetch64(s + 24), + a, + b); + } + + // na(97-256) farmhashna.cc + [MethodImpl(MethodImplOptions.AggressiveInlining)] + static unsafe ulong Hash64NA(byte* s, uint len) + { + const ulong seed = 81; + + unchecked + { + // For strings over 64 bytes we loop. Internal state consists of + // 56 bytes: v, w, x, y, and z. + ulong x = seed; + ulong y = seed * k1 + 113; + ulong z = ShiftMix(y * k2 + 113) * k2; + var v = make_pair(0, 0); + var w = make_pair(0, 0); + x = x * k2 + Fetch64(s); + + // Set end so that after the loop we have 1 to 64 bytes left to process. + byte* end = s + ((len - 1) / 64) * 64; + byte* last64 = end + ((len - 1) & 63) - 63; + + do + { + x = Rotate64(x + y + v.first + Fetch64(s + 8), 37) * k1; + y = Rotate64(y + v.second + Fetch64(s + 48), 42) * k1; + x ^= w.second; + y += v.first + Fetch64(s + 40); + z = Rotate64(z + w.first, 33) * k1; + v = WeakHashLen32WithSeeds(s, v.second * k1, x + w.first); + w = WeakHashLen32WithSeeds(s + 32, z + w.second, y + Fetch64(s + 16)); + swap(ref z, ref x); + s += 64; + } while (s != end); + ulong mul = k1 + ((z & 0xff) << 1); + // Make s point to the last 64 bytes of input. + s = last64; + w.first += ((len - 1) & 63); + v.first += w.first; + w.first += v.first; + x = Rotate64(x + y + v.first + Fetch64(s + 8), 37) * mul; + y = Rotate64(y + v.second + Fetch64(s + 48), 42) * mul; + x ^= w.second * 9; + y += v.first * 9 + Fetch64(s + 40); + z = Rotate64(z + w.first, 33) * mul; + v = WeakHashLen32WithSeeds(s, v.second * mul, x + w.first); + w = WeakHashLen32WithSeeds(s + 32, z + w.second, y + Fetch64(s + 16)); + swap(ref z, ref x); + return HashLen16(HashLen16(v.first, w.first, mul) + ShiftMix(y) * k0 + z, + HashLen16(v.second, w.second, mul) + x, + mul); + } + } + + // farmhashuo.cc + [MethodImpl(MethodImplOptions.AggressiveInlining)] + static ulong H(ulong x, ulong y, ulong mul, int r) + { + unchecked + { + ulong a = (x ^ y) * mul; + a ^= (a >> 47); + ulong b = (y ^ a) * mul; + return Rotate64(b, r) * mul; + } + } + + // uo(257-) farmhashuo.cc, Hash64WithSeeds + [MethodImpl(MethodImplOptions.AggressiveInlining)] + static unsafe ulong Hash64UO(byte* s, uint len) + { + const ulong seed0 = 81; + const ulong seed1 = 0; + + unchecked + { + // For strings over 64 bytes we loop. Internal state consists of + // 64 bytes: u, v, w, x, y, and z. + ulong x = seed0; + ulong y = seed1 * k2 + 113; + ulong z = ShiftMix(y * k2) * k2; + var v = make_pair(seed0, seed1); + var w = make_pair(0, 0); + ulong u = x - z; + x *= k2; + ulong mul = k2 + (u & 0x82); + + // Set end so that after the loop we have 1 to 64 bytes left to process. + byte* end = s + ((len - 1) / 64) * 64; + byte* last64 = end + ((len - 1) & 63) - 63; + + do + { + ulong a0 = Fetch64(s); + ulong a1 = Fetch64(s + 8); + ulong a2 = Fetch64(s + 16); + ulong a3 = Fetch64(s + 24); + ulong a4 = Fetch64(s + 32); + ulong a5 = Fetch64(s + 40); + ulong a6 = Fetch64(s + 48); + ulong a7 = Fetch64(s + 56); + x += a0 + a1; + y += a2; + z += a3; + v.first += a4; + v.second += a5 + a1; + w.first += a6; + w.second += a7; + + x = Rotate64(x, 26); + x *= 9; + y = Rotate64(y, 29); + z *= mul; + v.first = Rotate64(v.first, 33); + v.second = Rotate64(v.second, 30); + w.first ^= x; + w.first *= 9; + z = Rotate64(z, 32); + z += w.second; + w.second += z; + z *= 9; + swap(ref u, ref y); + + z += a0 + a6; + v.first += a2; + v.second += a3; + w.first += a4; + w.second += a5 + a6; + x += a1; + y += a7; + + y += v.first; + v.first += x - y; + v.second += w.first; + w.first += v.second; + w.second += x - y; + x += w.second; + w.second = Rotate64(w.second, 34); + swap(ref u, ref z); + s += 64; + } while (s != end); + // Make s point to the last 64 bytes of input. + s = last64; + u *= 9; + v.second = Rotate64(v.second, 28); + v.first = Rotate64(v.first, 20); + w.first += ((len - 1) & 63); + u += y; + y += u; + x = Rotate64(y - x + v.first + Fetch64(s + 8), 37) * mul; + y = Rotate64(y ^ v.second ^ Fetch64(s + 48), 42) * mul; + x ^= w.second * 9; + y += v.first + Fetch64(s + 40); + z = Rotate64(z + w.first, 33) * mul; + v = WeakHashLen32WithSeeds(s, v.second * mul, x + w.first); + w = WeakHashLen32WithSeeds(s + 32, z + w.second, y + Fetch64(s + 16)); + return H(HashLen16(v.first + x, w.first ^ y, mul) + z - u, + H(v.second + y, w.second + z, k2, 30) ^ x, + k2, + 31); + } + } + + #endregion + } +} + +#endif \ No newline at end of file diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/GuidBits.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/GuidBits.cs index c11b9c8b7..768ad2082 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/GuidBits.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/GuidBits.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 using System; using System.Runtime.InteropServices; diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/ILGeneratorExtensions.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/ILGeneratorExtensions.cs new file mode 100644 index 000000000..83683233d --- /dev/null +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/ILGeneratorExtensions.cs @@ -0,0 +1,400 @@ +//------------------------------------------------------------------------------ +// +// This file was automatically generated by the UpdateVendors tool. +//------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 +#if !UNITY_WSA +#if !NET_STANDARD_2_0 + +using System; +using System.Linq; +using System.Reflection; +using System.Reflection.Emit; + +namespace Datadog.Trace.Vendors.MessagePack.Internal +{ + internal struct ArgumentField + { + readonly int i; + readonly bool @ref; + readonly ILGenerator il; + + public ArgumentField(ILGenerator il, int i, bool @ref = false) + { + this.il = il; + this.i = i; + this.@ref = @ref; + } + + public ArgumentField(ILGenerator il, int i, Type type) + { + this.il = il; + this.i = i; + var ti = type.GetTypeInfo(); + this.@ref = (ti.IsClass || ti.IsInterface || ti.IsAbstract) ? false : true; + } + + public void EmitLoad() + { + if (@ref) + { + il.EmitLdarga(i); + } + else + { + il.EmitLdarg(i); + } + } + + public void EmitLdarg() + { + il.EmitLdarg(i); + } + + public void EmitLdarga() + { + il.EmitLdarga(i); + } + + public void EmitStore() + { + il.EmitStarg(i); + } + } + + /// + /// Provides optimized generation code and helpers. + /// + internal static class ILGeneratorExtensions + { + /// + /// Loads the local variable at a specific index onto the evaluation stack. + /// + public static void EmitLdloc(this ILGenerator il, int index) + { + switch (index) + { + case 0: + il.Emit(OpCodes.Ldloc_0); + break; + case 1: + il.Emit(OpCodes.Ldloc_1); + break; + case 2: + il.Emit(OpCodes.Ldloc_2); + break; + case 3: + il.Emit(OpCodes.Ldloc_3); + break; + default: + if (index <= 255) + { + il.Emit(OpCodes.Ldloc_S, (byte)index); + } + else + { + il.Emit(OpCodes.Ldloc, (short)index); + } + break; + } + } + + public static void EmitLdloc(this ILGenerator il, LocalBuilder local) + { + EmitLdloc(il, local.LocalIndex); + } + + /// + /// Pops the current value from the top of the evaluation stack and stores it in a the local variable list at a specified index. + /// + public static void EmitStloc(this ILGenerator il, int index) + { + switch (index) + { + case 0: + il.Emit(OpCodes.Stloc_0); + break; + case 1: + il.Emit(OpCodes.Stloc_1); + break; + case 2: + il.Emit(OpCodes.Stloc_2); + break; + case 3: + il.Emit(OpCodes.Stloc_3); + break; + default: + if (index <= 255) + { + il.Emit(OpCodes.Stloc_S, (byte)index); + } + else + { + il.Emit(OpCodes.Stloc, (short)index); + } + break; + } + } + + public static void EmitStloc(this ILGenerator il, LocalBuilder local) + { + EmitStloc(il, local.LocalIndex); + } + + /// + /// Loads the address of the local variable at a specific index onto the evaluation statck. + /// + public static void EmitLdloca(this ILGenerator il, int index) + { + if (index <= 255) + { + il.Emit(OpCodes.Ldloca_S, (byte)index); + } + else + { + il.Emit(OpCodes.Ldloca, (short)index); + } + } + + public static void EmitLdloca(this ILGenerator il, LocalBuilder local) + { + EmitLdloca(il, local.LocalIndex); + } + + public static void EmitTrue(this ILGenerator il) + { + EmitBoolean(il, true); + } + + public static void EmitFalse(this ILGenerator il) + { + EmitBoolean(il, false); + } + + public static void EmitBoolean(this ILGenerator il, bool value) + { + EmitLdc_I4(il, value ? 1 : 0); + } + + /// + /// Pushes a supplied value of type int32 onto the evaluation stack as an int32. + /// + public static void EmitLdc_I4(this ILGenerator il, int value) + { + switch (value) + { + case -1: + il.Emit(OpCodes.Ldc_I4_M1); + break; + case 0: + il.Emit(OpCodes.Ldc_I4_0); + break; + case 1: + il.Emit(OpCodes.Ldc_I4_1); + break; + case 2: + il.Emit(OpCodes.Ldc_I4_2); + break; + case 3: + il.Emit(OpCodes.Ldc_I4_3); + break; + case 4: + il.Emit(OpCodes.Ldc_I4_4); + break; + case 5: + il.Emit(OpCodes.Ldc_I4_5); + break; + case 6: + il.Emit(OpCodes.Ldc_I4_6); + break; + case 7: + il.Emit(OpCodes.Ldc_I4_7); + break; + case 8: + il.Emit(OpCodes.Ldc_I4_8); + break; + default: + if (value >= -128 && value <= 127) + { + il.Emit(OpCodes.Ldc_I4_S, (sbyte)value); + } + else + { + il.Emit(OpCodes.Ldc_I4, value); + } + break; + } + } + + public static void EmitUnboxOrCast(this ILGenerator il, Type type) + { + if (type.GetTypeInfo().IsValueType) + { + il.Emit(OpCodes.Unbox_Any, type); + } + else + { + il.Emit(OpCodes.Castclass, type); + } + } + + public static void EmitBoxOrDoNothing(this ILGenerator il, Type type) + { + if (type.GetTypeInfo().IsValueType) + { + il.Emit(OpCodes.Box, type); + } + } + + public static void EmitLdarg(this ILGenerator il, int index) + { + switch (index) + { + case 0: + il.Emit(OpCodes.Ldarg_0); + break; + case 1: + il.Emit(OpCodes.Ldarg_1); + break; + case 2: + il.Emit(OpCodes.Ldarg_2); + break; + case 3: + il.Emit(OpCodes.Ldarg_3); + break; + default: + if (index <= 255) + { + il.Emit(OpCodes.Ldarg_S, (byte)index); + } + else + { + il.Emit(OpCodes.Ldarg, index); + } + break; + } + } + + public static void EmitLoadThis(this ILGenerator il) + { + EmitLdarg(il, 0); + } + + public static void EmitLdarga(this ILGenerator il, int index) + { + if (index <= 255) + { + il.Emit(OpCodes.Ldarga_S, (byte)index); + } + else + { + il.Emit(OpCodes.Ldarga, index); + } + } + + public static void EmitStarg(this ILGenerator il, int index) + { + if (index <= 255) + { + il.Emit(OpCodes.Starg_S, (byte)index); + } + else + { + il.Emit(OpCodes.Starg, index); + } + } + + /// + /// Helper for Pop op. + /// + public static void EmitPop(this ILGenerator il, int count) + { + for (int i = 0; i < count; i++) + { + il.Emit(OpCodes.Pop); + } + } + + public static void EmitCall(this ILGenerator il, MethodInfo methodInfo) + { + if (methodInfo.IsFinal || !methodInfo.IsVirtual) + { + il.Emit(OpCodes.Call, methodInfo); + } + else + { + il.Emit(OpCodes.Callvirt, methodInfo); + } + } + + public static void EmitLdfld(this ILGenerator il, FieldInfo fieldInfo) + { + il.Emit(OpCodes.Ldfld, fieldInfo); + } + + public static void EmitLdsfld(this ILGenerator il, FieldInfo fieldInfo) + { + il.Emit(OpCodes.Ldsfld, fieldInfo); + } + + public static void EmitRet(this ILGenerator il) + { + il.Emit(OpCodes.Ret); + } + + public static void EmitIntZeroReturn(this ILGenerator il) + { + il.EmitLdc_I4(0); + il.Emit(OpCodes.Ret); + } + + public static void EmitNullReturn(this ILGenerator il) + { + il.Emit(OpCodes.Ldnull); + il.Emit(OpCodes.Ret); + } + + public static void EmitULong(this ILGenerator il, ulong value) + { + il.Emit(OpCodes.Ldc_I8, unchecked((long)value)); + } + + public static void EmitThrowNotimplemented(this ILGenerator il) + { + il.Emit(OpCodes.Newobj, typeof(System.NotImplementedException).GetTypeInfo().DeclaredConstructors.First(x => x.GetParameters().Length == 0)); + il.Emit(OpCodes.Throw); + } + + /// for var i = 0, i ..., i++ + public static void EmitIncrementFor(this ILGenerator il, LocalBuilder conditionGreater, Action emitBody) + { + var loopBegin = il.DefineLabel(); + var condtionLabel = il.DefineLabel(); + + // var i = 0 + var forI = il.DeclareLocal(typeof(int)); + il.EmitLdc_I4(0); + il.EmitStloc(forI); + il.Emit(OpCodes.Br, condtionLabel); + + il.MarkLabel(loopBegin); + emitBody(forI); + + // i++ + il.EmitLdloc(forI); + il.EmitLdc_I4(1); + il.Emit(OpCodes.Add); + il.EmitStloc(forI); + + //// i < *** + il.MarkLabel(condtionLabel); + il.EmitLdloc(forI); + il.EmitLdloc(conditionGreater); + il.Emit(OpCodes.Blt, loopBegin); + } + } + +} + +#endif +#endif \ No newline at end of file diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/ReflectionExtensions.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/ReflectionExtensions.cs index 1314bd193..20f9b1e84 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/ReflectionExtensions.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/ReflectionExtensions.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 #if !UNITY_WSA using System; @@ -37,7 +38,7 @@ public static bool IsIndexer(this System.Reflection.PropertyInfo propertyInfo) return propertyInfo.GetIndexParameters().Length > 0; } -#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +#if NETSTANDARD || NETFRAMEWORK public static bool IsConstructedGenericType(this System.Reflection.TypeInfo type) { diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/ThreadsafeTypeKeyHashTable.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/ThreadsafeTypeKeyHashTable.cs index b85cd73c2..af249eb47 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/ThreadsafeTypeKeyHashTable.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/ThreadsafeTypeKeyHashTable.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 using System; namespace Datadog.Trace.Vendors.MessagePack.Internal @@ -185,7 +186,7 @@ static int CalculateCapacity(int collectionSize, float loadFactor) static void VolatileWrite(ref Entry location, Entry value) { -#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +#if NETSTANDARD || NETFRAMEWORK System.Threading.Volatile.Write(ref location, value); #elif UNITY_WSA || NET_4_6 System.Threading.Volatile.Write(ref location, value); @@ -197,7 +198,7 @@ static void VolatileWrite(ref Entry location, Entry value) static void VolatileWrite(ref Entry[] location, Entry[] value) { -#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +#if NETSTANDARD || NETFRAMEWORK System.Threading.Volatile.Write(ref location, value); #elif UNITY_WSA || NET_4_6 System.Threading.Volatile.Write(ref location, value); diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/TinyJsonReader.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/TinyJsonReader.cs index 5287e1259..25d92c9c7 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/TinyJsonReader.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/TinyJsonReader.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 using System; using System.Globalization; using System.IO; diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/UnsafeMemory.Low.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/UnsafeMemory.Low.cs new file mode 100644 index 000000000..ca5e29ab1 --- /dev/null +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/UnsafeMemory.Low.cs @@ -0,0 +1,172 @@ +//------------------------------------------------------------------------------ +// +// This file was automatically generated by the UpdateVendors tool. +//------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 +#if NETSTANDARD || NETFRAMEWORK + +using System; +using System.Runtime.CompilerServices; + +namespace Datadog.Trace.Vendors.MessagePack.Internal +{ + // for string key property name write optimization. + + internal static class UnsafeMemory + { + public static readonly bool Is32Bit = (IntPtr.Size == 4); + } + + internal static partial class UnsafeMemory32 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw1(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(byte*)pDst = *(byte*)pSrc; + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw2(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(short*)pDst = *(short*)pSrc; + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw3(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(byte*)pDst = *(byte*)pSrc; + *(short*)(pDst + 1) = *(short*)(pSrc + 1); + } + + return src.Length; + } + } + + internal static partial class UnsafeMemory64 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw1(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(byte*)pDst = *(byte*)pSrc; + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw2(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(short*)pDst = *(short*)pSrc; + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw3(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(byte*)pDst = *(byte*)pSrc; + *(short*)(pDst + 1) = *(short*)(pSrc + 1); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw4(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(int*)(pDst + 0) = *(int*)(pSrc + 0); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw5(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(int*)(pDst + 0) = *(int*)(pSrc + 0); + *(int*)(pDst + 1) = *(int*)(pSrc + 1); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw6(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(int*)(pDst + 0) = *(int*)(pSrc + 0); + *(int*)(pDst + 2) = *(int*)(pSrc + 2); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw7(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(int*)(pDst + 0) = *(int*)(pSrc + 0); + *(int*)(pDst + 3) = *(int*)(pSrc + 3); + } + + return src.Length; + } + } +} + +#endif \ No newline at end of file diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/UnsafeMemory.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/UnsafeMemory.cs new file mode 100644 index 000000000..c821c0726 --- /dev/null +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/UnsafeMemory.cs @@ -0,0 +1,899 @@ +//------------------------------------------------------------------------------ +// +// This file was automatically generated by the UpdateVendors tool. +//------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 +#if NETSTANDARD || NETFRAMEWORK + +using System.Runtime.CompilerServices; + +namespace Datadog.Trace.Vendors.MessagePack.Internal +{ + internal static partial class UnsafeMemory32 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw4(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(int*)(pDst + 0) = *(int*)(pSrc + 0); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw5(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(int*)(pDst + 0) = *(int*)(pSrc + 0); + *(int*)(pDst + 1) = *(int*)(pSrc + 1); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw6(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(int*)(pDst + 0) = *(int*)(pSrc + 0); + *(int*)(pDst + 2) = *(int*)(pSrc + 2); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw7(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(int*)(pDst + 0) = *(int*)(pSrc + 0); + *(int*)(pDst + 3) = *(int*)(pSrc + 3); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw8(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(int*)(pDst + 0) = *(int*)(pSrc + 0); + *(int*)(pDst + 4) = *(int*)(pSrc + 4); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw9(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(int*)(pDst + 0) = *(int*)(pSrc + 0); + *(int*)(pDst + 4) = *(int*)(pSrc + 4); + *(int*)(pDst + 5) = *(int*)(pSrc + 5); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw10(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(int*)(pDst + 0) = *(int*)(pSrc + 0); + *(int*)(pDst + 4) = *(int*)(pSrc + 4); + *(int*)(pDst + 6) = *(int*)(pSrc + 6); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw11(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(int*)(pDst + 0) = *(int*)(pSrc + 0); + *(int*)(pDst + 4) = *(int*)(pSrc + 4); + *(int*)(pDst + 7) = *(int*)(pSrc + 7); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw12(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(int*)(pDst + 0) = *(int*)(pSrc + 0); + *(int*)(pDst + 4) = *(int*)(pSrc + 4); + *(int*)(pDst + 8) = *(int*)(pSrc + 8); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw13(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(int*)(pDst + 0) = *(int*)(pSrc + 0); + *(int*)(pDst + 4) = *(int*)(pSrc + 4); + *(int*)(pDst + 8) = *(int*)(pSrc + 8); + *(int*)(pDst + 9) = *(int*)(pSrc + 9); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw14(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(int*)(pDst + 0) = *(int*)(pSrc + 0); + *(int*)(pDst + 4) = *(int*)(pSrc + 4); + *(int*)(pDst + 8) = *(int*)(pSrc + 8); + *(int*)(pDst + 10) = *(int*)(pSrc + 10); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw15(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(int*)(pDst + 0) = *(int*)(pSrc + 0); + *(int*)(pDst + 4) = *(int*)(pSrc + 4); + *(int*)(pDst + 8) = *(int*)(pSrc + 8); + *(int*)(pDst + 11) = *(int*)(pSrc + 11); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw16(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(int*)(pDst + 0) = *(int*)(pSrc + 0); + *(int*)(pDst + 4) = *(int*)(pSrc + 4); + *(int*)(pDst + 8) = *(int*)(pSrc + 8); + *(int*)(pDst + 12) = *(int*)(pSrc + 12); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw17(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(int*)(pDst + 0) = *(int*)(pSrc + 0); + *(int*)(pDst + 4) = *(int*)(pSrc + 4); + *(int*)(pDst + 8) = *(int*)(pSrc + 8); + *(int*)(pDst + 12) = *(int*)(pSrc + 12); + *(int*)(pDst + 13) = *(int*)(pSrc + 13); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw18(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(int*)(pDst + 0) = *(int*)(pSrc + 0); + *(int*)(pDst + 4) = *(int*)(pSrc + 4); + *(int*)(pDst + 8) = *(int*)(pSrc + 8); + *(int*)(pDst + 12) = *(int*)(pSrc + 12); + *(int*)(pDst + 14) = *(int*)(pSrc + 14); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw19(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(int*)(pDst + 0) = *(int*)(pSrc + 0); + *(int*)(pDst + 4) = *(int*)(pSrc + 4); + *(int*)(pDst + 8) = *(int*)(pSrc + 8); + *(int*)(pDst + 12) = *(int*)(pSrc + 12); + *(int*)(pDst + 15) = *(int*)(pSrc + 15); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw20(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(int*)(pDst + 0) = *(int*)(pSrc + 0); + *(int*)(pDst + 4) = *(int*)(pSrc + 4); + *(int*)(pDst + 8) = *(int*)(pSrc + 8); + *(int*)(pDst + 12) = *(int*)(pSrc + 12); + *(int*)(pDst + 16) = *(int*)(pSrc + 16); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw21(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(int*)(pDst + 0) = *(int*)(pSrc + 0); + *(int*)(pDst + 4) = *(int*)(pSrc + 4); + *(int*)(pDst + 8) = *(int*)(pSrc + 8); + *(int*)(pDst + 12) = *(int*)(pSrc + 12); + *(int*)(pDst + 16) = *(int*)(pSrc + 16); + *(int*)(pDst + 17) = *(int*)(pSrc + 17); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw22(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(int*)(pDst + 0) = *(int*)(pSrc + 0); + *(int*)(pDst + 4) = *(int*)(pSrc + 4); + *(int*)(pDst + 8) = *(int*)(pSrc + 8); + *(int*)(pDst + 12) = *(int*)(pSrc + 12); + *(int*)(pDst + 16) = *(int*)(pSrc + 16); + *(int*)(pDst + 18) = *(int*)(pSrc + 18); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw23(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(int*)(pDst + 0) = *(int*)(pSrc + 0); + *(int*)(pDst + 4) = *(int*)(pSrc + 4); + *(int*)(pDst + 8) = *(int*)(pSrc + 8); + *(int*)(pDst + 12) = *(int*)(pSrc + 12); + *(int*)(pDst + 16) = *(int*)(pSrc + 16); + *(int*)(pDst + 19) = *(int*)(pSrc + 19); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw24(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(int*)(pDst + 0) = *(int*)(pSrc + 0); + *(int*)(pDst + 4) = *(int*)(pSrc + 4); + *(int*)(pDst + 8) = *(int*)(pSrc + 8); + *(int*)(pDst + 12) = *(int*)(pSrc + 12); + *(int*)(pDst + 16) = *(int*)(pSrc + 16); + *(int*)(pDst + 20) = *(int*)(pSrc + 20); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw25(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(int*)(pDst + 0) = *(int*)(pSrc + 0); + *(int*)(pDst + 4) = *(int*)(pSrc + 4); + *(int*)(pDst + 8) = *(int*)(pSrc + 8); + *(int*)(pDst + 12) = *(int*)(pSrc + 12); + *(int*)(pDst + 16) = *(int*)(pSrc + 16); + *(int*)(pDst + 20) = *(int*)(pSrc + 20); + *(int*)(pDst + 21) = *(int*)(pSrc + 21); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw26(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(int*)(pDst + 0) = *(int*)(pSrc + 0); + *(int*)(pDst + 4) = *(int*)(pSrc + 4); + *(int*)(pDst + 8) = *(int*)(pSrc + 8); + *(int*)(pDst + 12) = *(int*)(pSrc + 12); + *(int*)(pDst + 16) = *(int*)(pSrc + 16); + *(int*)(pDst + 20) = *(int*)(pSrc + 20); + *(int*)(pDst + 22) = *(int*)(pSrc + 22); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw27(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(int*)(pDst + 0) = *(int*)(pSrc + 0); + *(int*)(pDst + 4) = *(int*)(pSrc + 4); + *(int*)(pDst + 8) = *(int*)(pSrc + 8); + *(int*)(pDst + 12) = *(int*)(pSrc + 12); + *(int*)(pDst + 16) = *(int*)(pSrc + 16); + *(int*)(pDst + 20) = *(int*)(pSrc + 20); + *(int*)(pDst + 23) = *(int*)(pSrc + 23); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw28(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(int*)(pDst + 0) = *(int*)(pSrc + 0); + *(int*)(pDst + 4) = *(int*)(pSrc + 4); + *(int*)(pDst + 8) = *(int*)(pSrc + 8); + *(int*)(pDst + 12) = *(int*)(pSrc + 12); + *(int*)(pDst + 16) = *(int*)(pSrc + 16); + *(int*)(pDst + 20) = *(int*)(pSrc + 20); + *(int*)(pDst + 24) = *(int*)(pSrc + 24); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw29(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(int*)(pDst + 0) = *(int*)(pSrc + 0); + *(int*)(pDst + 4) = *(int*)(pSrc + 4); + *(int*)(pDst + 8) = *(int*)(pSrc + 8); + *(int*)(pDst + 12) = *(int*)(pSrc + 12); + *(int*)(pDst + 16) = *(int*)(pSrc + 16); + *(int*)(pDst + 20) = *(int*)(pSrc + 20); + *(int*)(pDst + 24) = *(int*)(pSrc + 24); + *(int*)(pDst + 25) = *(int*)(pSrc + 25); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw30(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(int*)(pDst + 0) = *(int*)(pSrc + 0); + *(int*)(pDst + 4) = *(int*)(pSrc + 4); + *(int*)(pDst + 8) = *(int*)(pSrc + 8); + *(int*)(pDst + 12) = *(int*)(pSrc + 12); + *(int*)(pDst + 16) = *(int*)(pSrc + 16); + *(int*)(pDst + 20) = *(int*)(pSrc + 20); + *(int*)(pDst + 24) = *(int*)(pSrc + 24); + *(int*)(pDst + 26) = *(int*)(pSrc + 26); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw31(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(int*)(pDst + 0) = *(int*)(pSrc + 0); + *(int*)(pDst + 4) = *(int*)(pSrc + 4); + *(int*)(pDst + 8) = *(int*)(pSrc + 8); + *(int*)(pDst + 12) = *(int*)(pSrc + 12); + *(int*)(pDst + 16) = *(int*)(pSrc + 16); + *(int*)(pDst + 20) = *(int*)(pSrc + 20); + *(int*)(pDst + 24) = *(int*)(pSrc + 24); + *(int*)(pDst + 27) = *(int*)(pSrc + 27); + } + + return src.Length; + } + + } + + internal static partial class UnsafeMemory64 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw8(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(long*)(pDst + 0) = *(long*)(pSrc + 0); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw9(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(long*)(pDst + 0) = *(long*)(pSrc + 0); + *(long*)(pDst + 1) = *(long*)(pSrc + 1); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw10(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(long*)(pDst + 0) = *(long*)(pSrc + 0); + *(long*)(pDst + 2) = *(long*)(pSrc + 2); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw11(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(long*)(pDst + 0) = *(long*)(pSrc + 0); + *(long*)(pDst + 3) = *(long*)(pSrc + 3); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw12(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(long*)(pDst + 0) = *(long*)(pSrc + 0); + *(long*)(pDst + 4) = *(long*)(pSrc + 4); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw13(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(long*)(pDst + 0) = *(long*)(pSrc + 0); + *(long*)(pDst + 5) = *(long*)(pSrc + 5); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw14(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(long*)(pDst + 0) = *(long*)(pSrc + 0); + *(long*)(pDst + 6) = *(long*)(pSrc + 6); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw15(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(long*)(pDst + 0) = *(long*)(pSrc + 0); + *(long*)(pDst + 7) = *(long*)(pSrc + 7); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw16(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(long*)(pDst + 0) = *(long*)(pSrc + 0); + *(long*)(pDst + 8) = *(long*)(pSrc + 8); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw17(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(long*)(pDst + 0) = *(long*)(pSrc + 0); + *(long*)(pDst + 8) = *(long*)(pSrc + 8); + *(long*)(pDst + 9) = *(long*)(pSrc + 9); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw18(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(long*)(pDst + 0) = *(long*)(pSrc + 0); + *(long*)(pDst + 8) = *(long*)(pSrc + 8); + *(long*)(pDst + 10) = *(long*)(pSrc + 10); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw19(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(long*)(pDst + 0) = *(long*)(pSrc + 0); + *(long*)(pDst + 8) = *(long*)(pSrc + 8); + *(long*)(pDst + 11) = *(long*)(pSrc + 11); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw20(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(long*)(pDst + 0) = *(long*)(pSrc + 0); + *(long*)(pDst + 8) = *(long*)(pSrc + 8); + *(long*)(pDst + 12) = *(long*)(pSrc + 12); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw21(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(long*)(pDst + 0) = *(long*)(pSrc + 0); + *(long*)(pDst + 8) = *(long*)(pSrc + 8); + *(long*)(pDst + 13) = *(long*)(pSrc + 13); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw22(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(long*)(pDst + 0) = *(long*)(pSrc + 0); + *(long*)(pDst + 8) = *(long*)(pSrc + 8); + *(long*)(pDst + 14) = *(long*)(pSrc + 14); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw23(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(long*)(pDst + 0) = *(long*)(pSrc + 0); + *(long*)(pDst + 8) = *(long*)(pSrc + 8); + *(long*)(pDst + 15) = *(long*)(pSrc + 15); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw24(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(long*)(pDst + 0) = *(long*)(pSrc + 0); + *(long*)(pDst + 8) = *(long*)(pSrc + 8); + *(long*)(pDst + 16) = *(long*)(pSrc + 16); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw25(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(long*)(pDst + 0) = *(long*)(pSrc + 0); + *(long*)(pDst + 8) = *(long*)(pSrc + 8); + *(long*)(pDst + 16) = *(long*)(pSrc + 16); + *(long*)(pDst + 17) = *(long*)(pSrc + 17); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw26(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(long*)(pDst + 0) = *(long*)(pSrc + 0); + *(long*)(pDst + 8) = *(long*)(pSrc + 8); + *(long*)(pDst + 16) = *(long*)(pSrc + 16); + *(long*)(pDst + 18) = *(long*)(pSrc + 18); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw27(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(long*)(pDst + 0) = *(long*)(pSrc + 0); + *(long*)(pDst + 8) = *(long*)(pSrc + 8); + *(long*)(pDst + 16) = *(long*)(pSrc + 16); + *(long*)(pDst + 19) = *(long*)(pSrc + 19); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw28(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(long*)(pDst + 0) = *(long*)(pSrc + 0); + *(long*)(pDst + 8) = *(long*)(pSrc + 8); + *(long*)(pDst + 16) = *(long*)(pSrc + 16); + *(long*)(pDst + 20) = *(long*)(pSrc + 20); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw29(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(long*)(pDst + 0) = *(long*)(pSrc + 0); + *(long*)(pDst + 8) = *(long*)(pSrc + 8); + *(long*)(pDst + 16) = *(long*)(pSrc + 16); + *(long*)(pDst + 21) = *(long*)(pSrc + 21); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw30(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(long*)(pDst + 0) = *(long*)(pSrc + 0); + *(long*)(pDst + 8) = *(long*)(pSrc + 8); + *(long*)(pDst + 16) = *(long*)(pSrc + 16); + *(long*)(pDst + 22) = *(long*)(pSrc + 22); + } + + return src.Length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int WriteRaw31(ref byte[] dst, int dstOffset, byte[] src) + { + MessagePackBinary.EnsureCapacity(ref dst, dstOffset, src.Length); + + fixed (byte* pSrc = &src[0]) + fixed (byte* pDst = &dst[dstOffset]) + { + *(long*)(pDst + 0) = *(long*)(pSrc + 0); + *(long*)(pDst + 8) = *(long*)(pSrc + 8); + *(long*)(pDst + 16) = *(long*)(pSrc + 16); + *(long*)(pDst + 23) = *(long*)(pSrc + 23); + } + + return src.Length; + } + + } +} + +#endif \ No newline at end of file diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/UnsafeMemory.tt b/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/UnsafeMemory.tt index e02afff36..cc5037998 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/UnsafeMemory.tt +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Internal/UnsafeMemory.tt @@ -7,7 +7,7 @@ <# var Max = 31; #> -#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +#if NETSTANDARD || NETFRAMEWORK using System.Runtime.CompilerServices; diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/Codec/LZ4Codec.Helper.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/Codec/LZ4Codec.Helper.cs index 6041c02c4..6d2bc0c7c 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/Codec/LZ4Codec.Helper.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/Codec/LZ4Codec.Helper.cs @@ -2,12 +2,41 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 using System; namespace Datadog.Trace.Vendors.MessagePack.LZ4 { internal static partial class LZ4Codec { +#if ENABLE_UNSAFE_MSGPACK + + public static int Encode(byte[] input, int inputOffset, int inputLength, byte[] output, int outputOffset, int outputLength) + { + if (IntPtr.Size == 4) + { + return LZ4Codec.Encode32Unsafe(input, inputOffset, inputLength, output, outputOffset, outputLength); + } + else + { + return LZ4Codec.Encode64Unsafe(input, inputOffset, inputLength, output, outputOffset, outputLength); + } + } + + public static int Decode(byte[] input, int inputOffset, int inputLength, byte[] output, int outputOffset, int outputLength) + { + if (IntPtr.Size == 4) + { + return LZ4Codec.Decode32Unsafe(input, inputOffset, inputLength, output, outputOffset, outputLength); + } + else + { + return LZ4Codec.Decode64Unsafe(input, inputOffset, inputLength, output, outputOffset, outputLength); + } + } + +#else + // use 'Safe' code for Unity because in IL2CPP gots strange behaviour. public static int Encode(byte[] input, int inputOffset, int inputLength, byte[] output, int outputOffset, int outputLength) @@ -34,6 +63,8 @@ public static int Decode(byte[] input, int inputOffset, int inputLength, byte[] } } +#endif + internal static class HashTablePool { [ThreadStatic] diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/Codec/LZ4Codec.Safe.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/Codec/LZ4Codec.Safe.cs index 9f9464bf0..862ac8022 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/Codec/LZ4Codec.Safe.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/Codec/LZ4Codec.Safe.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 #region license /* diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/Codec/LZ4Codec.Safe32.Dirty.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/Codec/LZ4Codec.Safe32.Dirty.cs index 6bb877da0..cddb95b3e 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/Codec/LZ4Codec.Safe32.Dirty.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/Codec/LZ4Codec.Safe32.Dirty.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 #region LZ4 original /* diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/Codec/LZ4Codec.Safe64.Dirty.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/Codec/LZ4Codec.Safe64.Dirty.cs index de75db4f1..23023422b 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/Codec/LZ4Codec.Safe64.Dirty.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/Codec/LZ4Codec.Safe64.Dirty.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 #region LZ4 original /* diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/Codec/LZ4Codec.Unsafe.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/Codec/LZ4Codec.Unsafe.cs index e18c35f82..1e0237b49 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/Codec/LZ4Codec.Unsafe.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/Codec/LZ4Codec.Unsafe.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 #if ENABLE_UNSAFE_MSGPACK #region license diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/Codec/LZ4Codec.Unsafe32.Dirty.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/Codec/LZ4Codec.Unsafe32.Dirty.cs index a54811ee8..2f499697f 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/Codec/LZ4Codec.Unsafe32.Dirty.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/Codec/LZ4Codec.Unsafe32.Dirty.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 #if ENABLE_UNSAFE_MSGPACK #region LZ4 original diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/Codec/LZ4Codec.Unsafe64.Dirty.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/Codec/LZ4Codec.Unsafe64.Dirty.cs index 387e61467..2c9f29eae 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/Codec/LZ4Codec.Unsafe64.Dirty.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/Codec/LZ4Codec.Unsafe64.Dirty.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 #if ENABLE_UNSAFE_MSGPACK #region LZ4 original diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/Codec/LZ4Codec.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/Codec/LZ4Codec.cs index 58daa1969..f1c77c47e 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/Codec/LZ4Codec.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/Codec/LZ4Codec.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 #region license /* diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/LZ4MessagePackSerializer.JSON.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/LZ4MessagePackSerializer.JSON.cs index a043e3c7a..963eacf68 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/LZ4MessagePackSerializer.JSON.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/LZ4MessagePackSerializer.JSON.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 using Datadog.Trace.Vendors.MessagePack.Formatters; using Datadog.Trace.Vendors.MessagePack.Internal; using Datadog.Trace.Vendors.MessagePack.LZ4; @@ -196,6 +197,39 @@ static int ToJsonCore(byte[] bytes, int offset, StringBuilder builder) builder.Append(dt.ToString("o", CultureInfo.InvariantCulture)); builder.Append("\""); } +#if NETSTANDARD || NETFRAMEWORK + else if (extHeader.TypeCode == TypelessFormatter.ExtensionTypeCode) + { + int startOffset = offset; + // prepare type name token + offset += 6; + var typeNameToken = new StringBuilder(); + var typeNameReadSize = ToJsonCore(bytes, offset, typeNameToken); + offset += typeNameReadSize; + int startBuilderLength = builder.Length; + if (extHeader.Length > typeNameReadSize) + { + // object map or array + var typeInside = MessagePackBinary.GetMessagePackType(bytes, offset); + if (typeInside != MessagePackType.Array && typeInside != MessagePackType.Map) + builder.Append("{"); + offset += ToJsonCore(bytes, offset, builder); + // insert type name token to start of object map or array + if (typeInside != MessagePackType.Array) + typeNameToken.Insert(0, "\"$type\":"); + if (typeInside != MessagePackType.Array && typeInside != MessagePackType.Map) + builder.Append("}"); + if (builder.Length - startBuilderLength > 2) + typeNameToken.Append(","); + builder.Insert(startBuilderLength + 1, typeNameToken.ToString()); + } + else + { + builder.Append("{\"$type\":\"" + typeNameToken.ToString() + "}"); + } + readSize = offset - startOffset; + } +#endif else { var ext = MessagePackBinary.ReadExtensionFormat(bytes, offset, out readSize); diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/LZ4MessagePackSerializer.NonGeneric.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/LZ4MessagePackSerializer.NonGeneric.cs index da255ba1c..9e65634b0 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/LZ4MessagePackSerializer.NonGeneric.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/LZ4MessagePackSerializer.NonGeneric.cs @@ -2,7 +2,8 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ -#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 +#if NETSTANDARD || NETFRAMEWORK using System; using System.Linq; diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/LZ4MessagePackSerializer.Typeless.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/LZ4MessagePackSerializer.Typeless.cs new file mode 100644 index 000000000..b5c1f4689 --- /dev/null +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/LZ4MessagePackSerializer.Typeless.cs @@ -0,0 +1,105 @@ +//------------------------------------------------------------------------------ +// +// This file was automatically generated by the UpdateVendors tool. +//------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 +#if NETSTANDARD || NETFRAMEWORK + +using System; +using System.Collections.Generic; +using System.Text; +using Datadog.Trace.Vendors.MessagePack.Resolvers; +using Datadog.Trace.Vendors.MessagePack.Formatters; +using System.IO; + +namespace Datadog.Trace.Vendors.MessagePack +{ + // Typeless API + internal static partial class LZ4MessagePackSerializer + { + internal static class Typeless + { + static IFormatterResolver defaultResolver = MessagePack.Resolvers.TypelessContractlessStandardResolver.Instance; + + public static void RegisterDefaultResolver(params IFormatterResolver[] resolvers) + { + CompositeResolver.Register(resolvers); + defaultResolver = CompositeResolver.Instance; + } + + public static byte[] Serialize(object obj) + { + return LZ4MessagePackSerializer.Serialize(obj, defaultResolver); + } + + public static void Serialize(Stream stream, object obj) + { + LZ4MessagePackSerializer.Serialize(stream, obj, defaultResolver); + } + + public static object Deserialize(byte[] bytes) + { + return LZ4MessagePackSerializer.Deserialize(bytes, defaultResolver); + } + + public static object Deserialize(Stream stream) + { + return LZ4MessagePackSerializer.Deserialize(stream, defaultResolver); + } + + public static object Deserialize(Stream stream, bool readStrict) + { + return LZ4MessagePackSerializer.Deserialize(stream, defaultResolver, readStrict); + } + + class CompositeResolver : IFormatterResolver + { + public static readonly CompositeResolver Instance = new CompositeResolver(); + + static bool isFreezed = false; + static IFormatterResolver[] resolvers = new IFormatterResolver[0]; + + CompositeResolver() + { + } + + public static void Register(params IFormatterResolver[] resolvers) + { + if (isFreezed) + { + throw new InvalidOperationException("Register must call on startup(before use GetFormatter)."); + } + + CompositeResolver.resolvers = resolvers; + } + + public IMessagePackFormatter GetFormatter() + { + return FormatterCache.formatter; + } + + static class FormatterCache + { + public static readonly IMessagePackFormatter formatter; + + static FormatterCache() + { + isFreezed = true; + + foreach (var item in resolvers) + { + var f = item.GetFormatter(); + if (f != null) + { + formatter = f; + return; + } + } + } + } + } + } + } +} + +#endif \ No newline at end of file diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/LZ4MessagePackSerializer.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/LZ4MessagePackSerializer.cs index f01d14505..6b5154210 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/LZ4MessagePackSerializer.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/LZ4/LZ4MessagePackSerializer.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 using Datadog.Trace.Vendors.MessagePack.Internal; using System; using System.IO; diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/MessagePackBinary.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/MessagePackBinary.cs index d70267c27..45a6eb28b 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/MessagePackBinary.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/MessagePackBinary.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 using Datadog.Trace.Vendors.MessagePack.Decoders; using Datadog.Trace.Vendors.MessagePack.Internal; using System; @@ -452,7 +453,215 @@ public static bool IsNil(byte[] bytes, int offset) public static int WriteRaw(ref byte[] bytes, int offset, byte[] rawMessagePackBlock) { EnsureCapacity(ref bytes, offset, rawMessagePackBlock.Length); + +#if NETSTANDARD || NETFRAMEWORK + if (UnsafeMemory.Is32Bit) + { + switch (rawMessagePackBlock.Length) + { + case 1: + UnsafeMemory32.WriteRaw1(ref bytes, offset, rawMessagePackBlock); + break; + case 2: + UnsafeMemory32.WriteRaw2(ref bytes, offset, rawMessagePackBlock); + break; + case 3: + UnsafeMemory32.WriteRaw3(ref bytes, offset, rawMessagePackBlock); + break; + case 4: + UnsafeMemory32.WriteRaw4(ref bytes, offset, rawMessagePackBlock); + break; + case 5: + UnsafeMemory32.WriteRaw5(ref bytes, offset, rawMessagePackBlock); + break; + case 6: + UnsafeMemory32.WriteRaw6(ref bytes, offset, rawMessagePackBlock); + break; + case 7: + UnsafeMemory32.WriteRaw7(ref bytes, offset, rawMessagePackBlock); + break; + case 8: + UnsafeMemory32.WriteRaw8(ref bytes, offset, rawMessagePackBlock); + break; + case 9: + UnsafeMemory32.WriteRaw9(ref bytes, offset, rawMessagePackBlock); + break; + case 10: + UnsafeMemory32.WriteRaw10(ref bytes, offset, rawMessagePackBlock); + break; + case 11: + UnsafeMemory32.WriteRaw11(ref bytes, offset, rawMessagePackBlock); + break; + case 12: + UnsafeMemory32.WriteRaw12(ref bytes, offset, rawMessagePackBlock); + break; + case 13: + UnsafeMemory32.WriteRaw13(ref bytes, offset, rawMessagePackBlock); + break; + case 14: + UnsafeMemory32.WriteRaw14(ref bytes, offset, rawMessagePackBlock); + break; + case 15: + UnsafeMemory32.WriteRaw15(ref bytes, offset, rawMessagePackBlock); + break; + case 16: + UnsafeMemory32.WriteRaw16(ref bytes, offset, rawMessagePackBlock); + break; + case 17: + UnsafeMemory32.WriteRaw17(ref bytes, offset, rawMessagePackBlock); + break; + case 18: + UnsafeMemory32.WriteRaw18(ref bytes, offset, rawMessagePackBlock); + break; + case 19: + UnsafeMemory32.WriteRaw19(ref bytes, offset, rawMessagePackBlock); + break; + case 20: + UnsafeMemory32.WriteRaw20(ref bytes, offset, rawMessagePackBlock); + break; + case 21: + UnsafeMemory32.WriteRaw21(ref bytes, offset, rawMessagePackBlock); + break; + case 22: + UnsafeMemory32.WriteRaw22(ref bytes, offset, rawMessagePackBlock); + break; + case 23: + UnsafeMemory32.WriteRaw23(ref bytes, offset, rawMessagePackBlock); + break; + case 24: + UnsafeMemory32.WriteRaw24(ref bytes, offset, rawMessagePackBlock); + break; + case 25: + UnsafeMemory32.WriteRaw25(ref bytes, offset, rawMessagePackBlock); + break; + case 26: + UnsafeMemory32.WriteRaw26(ref bytes, offset, rawMessagePackBlock); + break; + case 27: + UnsafeMemory32.WriteRaw27(ref bytes, offset, rawMessagePackBlock); + break; + case 28: + UnsafeMemory32.WriteRaw28(ref bytes, offset, rawMessagePackBlock); + break; + case 29: + UnsafeMemory32.WriteRaw29(ref bytes, offset, rawMessagePackBlock); + break; + case 30: + UnsafeMemory32.WriteRaw30(ref bytes, offset, rawMessagePackBlock); + break; + case 31: + UnsafeMemory32.WriteRaw31(ref bytes, offset, rawMessagePackBlock); + break; + default: + Buffer.BlockCopy(rawMessagePackBlock, 0, bytes, offset, rawMessagePackBlock.Length); + break; + } + } + else + { + switch (rawMessagePackBlock.Length) + { + case 1: + UnsafeMemory64.WriteRaw1(ref bytes, offset, rawMessagePackBlock); + break; + case 2: + UnsafeMemory64.WriteRaw2(ref bytes, offset, rawMessagePackBlock); + break; + case 3: + UnsafeMemory64.WriteRaw3(ref bytes, offset, rawMessagePackBlock); + break; + case 4: + UnsafeMemory64.WriteRaw4(ref bytes, offset, rawMessagePackBlock); + break; + case 5: + UnsafeMemory64.WriteRaw5(ref bytes, offset, rawMessagePackBlock); + break; + case 6: + UnsafeMemory64.WriteRaw6(ref bytes, offset, rawMessagePackBlock); + break; + case 7: + UnsafeMemory64.WriteRaw7(ref bytes, offset, rawMessagePackBlock); + break; + case 8: + UnsafeMemory64.WriteRaw8(ref bytes, offset, rawMessagePackBlock); + break; + case 9: + UnsafeMemory64.WriteRaw9(ref bytes, offset, rawMessagePackBlock); + break; + case 10: + UnsafeMemory64.WriteRaw10(ref bytes, offset, rawMessagePackBlock); + break; + case 11: + UnsafeMemory64.WriteRaw11(ref bytes, offset, rawMessagePackBlock); + break; + case 12: + UnsafeMemory64.WriteRaw12(ref bytes, offset, rawMessagePackBlock); + break; + case 13: + UnsafeMemory64.WriteRaw13(ref bytes, offset, rawMessagePackBlock); + break; + case 14: + UnsafeMemory64.WriteRaw14(ref bytes, offset, rawMessagePackBlock); + break; + case 15: + UnsafeMemory64.WriteRaw15(ref bytes, offset, rawMessagePackBlock); + break; + case 16: + UnsafeMemory64.WriteRaw16(ref bytes, offset, rawMessagePackBlock); + break; + case 17: + UnsafeMemory64.WriteRaw17(ref bytes, offset, rawMessagePackBlock); + break; + case 18: + UnsafeMemory64.WriteRaw18(ref bytes, offset, rawMessagePackBlock); + break; + case 19: + UnsafeMemory64.WriteRaw19(ref bytes, offset, rawMessagePackBlock); + break; + case 20: + UnsafeMemory64.WriteRaw20(ref bytes, offset, rawMessagePackBlock); + break; + case 21: + UnsafeMemory64.WriteRaw21(ref bytes, offset, rawMessagePackBlock); + break; + case 22: + UnsafeMemory64.WriteRaw22(ref bytes, offset, rawMessagePackBlock); + break; + case 23: + UnsafeMemory64.WriteRaw23(ref bytes, offset, rawMessagePackBlock); + break; + case 24: + UnsafeMemory64.WriteRaw24(ref bytes, offset, rawMessagePackBlock); + break; + case 25: + UnsafeMemory64.WriteRaw25(ref bytes, offset, rawMessagePackBlock); + break; + case 26: + UnsafeMemory64.WriteRaw26(ref bytes, offset, rawMessagePackBlock); + break; + case 27: + UnsafeMemory64.WriteRaw27(ref bytes, offset, rawMessagePackBlock); + break; + case 28: + UnsafeMemory64.WriteRaw28(ref bytes, offset, rawMessagePackBlock); + break; + case 29: + UnsafeMemory64.WriteRaw29(ref bytes, offset, rawMessagePackBlock); + break; + case 30: + UnsafeMemory64.WriteRaw30(ref bytes, offset, rawMessagePackBlock); + break; + case 31: + UnsafeMemory64.WriteRaw31(ref bytes, offset, rawMessagePackBlock); + break; + default: + Buffer.BlockCopy(rawMessagePackBlock, 0, bytes, offset, rawMessagePackBlock.Length); + break; + } + } +#else Buffer.BlockCopy(rawMessagePackBlock, 0, bytes, offset, rawMessagePackBlock.Length); +#endif return rawMessagePackBlock.Length; } @@ -5926,4 +6135,4 @@ public int Read(byte[] bytes, int offset) return (int)length + 6; } } -} +} \ No newline at end of file diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/MessagePackCode.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/MessagePackCode.cs index 350135b66..42e572784 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/MessagePackCode.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/MessagePackCode.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 using System; using System.Collections.Generic; using System.Text; diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/MessagePackSecurity.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/MessagePackSecurity.cs index 0f993a84c..3a231363a 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/MessagePackSecurity.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/MessagePackSecurity.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 // Copyright (c) All contributors. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. @@ -60,6 +61,7 @@ private MessagePackSecurity() /// /// The template to copy from. protected MessagePackSecurity(MessagePackSecurity copyFrom) + : this() { if (copyFrom is null) { @@ -160,32 +162,54 @@ public IEqualityComparer GetEqualityComparer() /// A hash collision resistant equality comparer. protected virtual IEqualityComparer GetHashCollisionResistantEqualityComparer() { - // For anything 32-bits and under, our fallback base secure hasher is usually adequate since it makes the hash unpredictable. - // We should have special implementations for any value that is larger than 32-bits in order to make sure - // that all the data gets hashed securely rather than trivially and predictably compressed into 32-bits before being hashed. - // We also have to specially handle some 32-bit types (e.g. float) where multiple in-memory representations should hash to the same value. - // Any type supported by the PrimitiveObjectFormatter should be added here if supporting it as a key in a collection makes sense. - return - // 32-bits or smaller: - typeof(T) == typeof(bool) ? CollisionResistantHasher.Instance : - typeof(T) == typeof(char) ? CollisionResistantHasher.Instance : - typeof(T) == typeof(sbyte) ? CollisionResistantHasher.Instance : - typeof(T) == typeof(byte) ? CollisionResistantHasher.Instance : - typeof(T) == typeof(short) ? CollisionResistantHasher.Instance : - typeof(T) == typeof(ushort) ? CollisionResistantHasher.Instance : - typeof(T) == typeof(int) ? CollisionResistantHasher.Instance : - typeof(T) == typeof(uint) ? CollisionResistantHasher.Instance : - - // Larger than 32-bits (or otherwise require special handling): - typeof(T) == typeof(long) ? (IEqualityComparer)Int64EqualityComparer.Instance : - typeof(T) == typeof(ulong) ? (IEqualityComparer)UInt64EqualityComparer.Instance : - typeof(T) == typeof(string) ? (IEqualityComparer)StringEqualityComparer.Instance : - typeof(T) == typeof(object) ? (IEqualityComparer)this.objectFallbackEqualityComparer : - - // Any type we don't explicitly whitelist here shouldn't be allowed to use as the key in a hash-based collection since it isn't known to be hash resistant. - // This method can of course be overridden to add more hash collision resistant type support, or the deserializing party can indicate that the data is Trusted - // so that this method doesn't even get called. - throw new TypeAccessException($"No hash-resistant equality comparer available for type: {typeof(T)}"); + IEqualityComparer result = null; + if (typeof(T).GetTypeInfo().IsEnum) + { + Type underlyingType = typeof(T).GetTypeInfo().GetEnumUnderlyingType(); + result = + underlyingType == typeof(sbyte) ? CollisionResistantHasher.Instance : + underlyingType == typeof(byte) ? CollisionResistantHasher.Instance : + underlyingType == typeof(short) ? CollisionResistantHasher.Instance : + underlyingType == typeof(ushort) ? CollisionResistantHasher.Instance : + underlyingType == typeof(int) ? CollisionResistantHasher.Instance : + underlyingType == typeof(uint) ? CollisionResistantHasher.Instance : + null; + } + else + { + // For anything 32-bits and under, our fallback base secure hasher is usually adequate since it makes the hash unpredictable. + // We should have special implementations for any value that is larger than 32-bits in order to make sure + // that all the data gets hashed securely rather than trivially and predictably compressed into 32-bits before being hashed. + // We also have to specially handle some 32-bit types (e.g. float) where multiple in-memory representations should hash to the same value. + // Any type supported by the PrimitiveObjectFormatter should be added here if supporting it as a key in a collection makes sense. + result = + // 32-bits or smaller: + typeof(T) == typeof(bool) ? CollisionResistantHasher.Instance : + typeof(T) == typeof(char) ? CollisionResistantHasher.Instance : + typeof(T) == typeof(sbyte) ? CollisionResistantHasher.Instance : + typeof(T) == typeof(byte) ? CollisionResistantHasher.Instance : + typeof(T) == typeof(short) ? CollisionResistantHasher.Instance : + typeof(T) == typeof(ushort) ? CollisionResistantHasher.Instance : + typeof(T) == typeof(int) ? CollisionResistantHasher.Instance : + typeof(T) == typeof(uint) ? CollisionResistantHasher.Instance : + + // Larger than 32-bits (or otherwise require special handling): + typeof(T) == typeof(long) ? (IEqualityComparer)Int64EqualityComparer.Instance : + typeof(T) == typeof(ulong) ? (IEqualityComparer)UInt64EqualityComparer.Instance : + typeof(T) == typeof(float) ? (IEqualityComparer)SingleEqualityComparer.Instance : + typeof(T) == typeof(double) ? (IEqualityComparer)DoubleEqualityComparer.Instance : + typeof(T) == typeof(string) ? (IEqualityComparer)StringEqualityComparer.Instance : + typeof(T) == typeof(Guid) ? (IEqualityComparer)GuidEqualityComparer.Instance : + typeof(T) == typeof(DateTime) ? (IEqualityComparer)DateTimeEqualityComparer.Instance : + typeof(T) == typeof(DateTimeOffset) ? (IEqualityComparer)DateTimeOffsetEqualityComparer.Instance : + typeof(T) == typeof(object) ? (IEqualityComparer)this.objectFallbackEqualityComparer : + null; + } + + // Any type we don't explicitly whitelist here shouldn't be allowed to use as the key in a hash-based collection since it isn't known to be hash resistant. + // This method can of course be overridden to add more hash collision resistant type support, or the deserializing party can indicate that the data is Trusted + // so that this method doesn't even get called. + return result ?? throw new TypeAccessException($"No hash-resistant equality comparer available for type: {typeof(T)}"); } /// @@ -340,6 +364,69 @@ private class Int64EqualityComparer : CollisionResistantHasher public override int GetHashCode(long value) => HashCode.Combine((int)(value >> 32), unchecked((int)value)); } + private class SingleEqualityComparer : CollisionResistantHasher + { + internal static new readonly SingleEqualityComparer Instance = new SingleEqualityComparer(); + + public override unsafe int GetHashCode(float value) + { + // Special check for 0.0 so that the hash of 0.0 and -0.0 will equal. + if (value == 0.0f) + { + return HashCode.Combine(0); + } + + // Standardize on the binary representation of NaN prior to hashing. + if (float.IsNaN(value)) + { + value = float.NaN; + } + + long l = *(long*)&value; + return HashCode.Combine((int)(l >> 32), unchecked((int)l)); + } + } + + private class DoubleEqualityComparer : CollisionResistantHasher + { + internal static new readonly DoubleEqualityComparer Instance = new DoubleEqualityComparer(); + + public override unsafe int GetHashCode(double value) + { + // Special check for 0.0 so that the hash of 0.0 and -0.0 will equal. + if (value == 0.0) + { + return HashCode.Combine(0); + } + + // Standardize on the binary representation of NaN prior to hashing. + if (double.IsNaN(value)) + { + value = double.NaN; + } + + long l = *(long*)&value; + return HashCode.Combine((int)(l >> 32), unchecked((int)l)); + } + } + + private class GuidEqualityComparer : CollisionResistantHasher + { + internal static new readonly GuidEqualityComparer Instance = new GuidEqualityComparer(); + + public override unsafe int GetHashCode(Guid value) + { + var hash = default(HashCode); + int* pGuid = (int*)&value; + for (int i = 0; i < sizeof(Guid) / sizeof(int); i++) + { + hash.Add(pGuid[i]); + } + + return hash.ToHashCode(); + } + } + private class StringEqualityComparer : CollisionResistantHasher { internal static new readonly StringEqualityComparer Instance = new StringEqualityComparer(); @@ -360,5 +447,19 @@ public override int GetHashCode(string value) #endif } } + + private class DateTimeEqualityComparer : CollisionResistantHasher + { + internal static new readonly DateTimeEqualityComparer Instance = new DateTimeEqualityComparer(); + + public override unsafe int GetHashCode(DateTime value) => HashCode.Combine((int)(value.Ticks >> 32), unchecked((int)value.Ticks), value.Kind); + } + + private class DateTimeOffsetEqualityComparer : CollisionResistantHasher + { + internal static new readonly DateTimeOffsetEqualityComparer Instance = new DateTimeOffsetEqualityComparer(); + + public override unsafe int GetHashCode(DateTimeOffset value) => HashCode.Combine((int)(value.UtcTicks >> 32), unchecked((int)value.UtcTicks)); + } } } diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/MessagePackSerializer.Json.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/MessagePackSerializer.Json.cs index 3184f9267..ec4c166fd 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/MessagePackSerializer.Json.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/MessagePackSerializer.Json.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 using Datadog.Trace.Vendors.MessagePack.Formatters; using Datadog.Trace.Vendors.MessagePack.Internal; using System; @@ -272,6 +273,39 @@ static int ToJsonCore(byte[] bytes, int offset, StringBuilder builder) builder.Append(dt.ToString("o", CultureInfo.InvariantCulture)); builder.Append("\""); } +#if NETSTANDARD || NETFRAMEWORK + else if (extHeader.TypeCode == TypelessFormatter.ExtensionTypeCode) + { + int startOffset = offset; + // prepare type name token + offset += 6; + var typeNameToken = new StringBuilder(); + var typeNameReadSize = ToJsonCore(bytes, offset, typeNameToken); + offset += typeNameReadSize; + int startBuilderLength = builder.Length; + if (extHeader.Length > typeNameReadSize) + { + // object map or array + var typeInside = MessagePackBinary.GetMessagePackType(bytes, offset); + if (typeInside != MessagePackType.Array && typeInside != MessagePackType.Map) + builder.Append("{"); + offset += ToJsonCore(bytes, offset, builder); + // insert type name token to start of object map or array + if (typeInside != MessagePackType.Array) + typeNameToken.Insert(0, "\"$type\":"); + if (typeInside != MessagePackType.Array && typeInside != MessagePackType.Map) + builder.Append("}"); + if (builder.Length - startBuilderLength > 2) + typeNameToken.Append(","); + builder.Insert(startBuilderLength + 1, typeNameToken.ToString()); + } + else + { + builder.Append("{\"$type\":\"" + typeNameToken.ToString() + "}"); + } + readSize = offset - startOffset; + } +#endif else { var ext = MessagePackBinary.ReadExtensionFormat(bytes, offset, out readSize); @@ -336,4 +370,4 @@ static void WriteJsonString(string value, StringBuilder builder) builder.Append('\"'); } } -} +} \ No newline at end of file diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/MessagePackSerializer.NonGeneric.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/MessagePackSerializer.NonGeneric.cs index 235ce4dc1..355bdbee1 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/MessagePackSerializer.NonGeneric.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/MessagePackSerializer.NonGeneric.cs @@ -2,7 +2,8 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ -#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 +#if NETSTANDARD || NETFRAMEWORK using System; using System.IO; diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/MessagePackSerializer.Typeless.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/MessagePackSerializer.Typeless.cs new file mode 100644 index 000000000..5bc45d7e3 --- /dev/null +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/MessagePackSerializer.Typeless.cs @@ -0,0 +1,115 @@ +//------------------------------------------------------------------------------ +// +// This file was automatically generated by the UpdateVendors tool. +//------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 +#if NETSTANDARD || NETFRAMEWORK + +using System; +using System.Collections.Generic; +using System.Text; +using Datadog.Trace.Vendors.MessagePack.Resolvers; +using Datadog.Trace.Vendors.MessagePack.Formatters; +using System.IO; + +namespace Datadog.Trace.Vendors.MessagePack +{ + // Typeless API + internal static partial class MessagePackSerializer + { + internal static class Typeless + { + static IFormatterResolver defaultResolver = MessagePack.Resolvers.TypelessContractlessStandardResolver.Instance; + + public static void RegisterDefaultResolver(params IFormatterResolver[] resolvers) + { + CompositeResolver.Register(resolvers); + defaultResolver = CompositeResolver.Instance; + } + + public static byte[] Serialize(object obj) + { + return MessagePackSerializer.Serialize(obj, defaultResolver); + } + + public static void Serialize(Stream stream, object obj) + { + MessagePackSerializer.Serialize(stream, obj, defaultResolver); + } + + public static System.Threading.Tasks.Task SerializeAsync(Stream stream, object obj) + { + return MessagePackSerializer.SerializeAsync(stream, obj, defaultResolver); + } + + public static object Deserialize(byte[] bytes) + { + return MessagePackSerializer.Deserialize(bytes, defaultResolver); + } + + public static object Deserialize(Stream stream) + { + return MessagePackSerializer.Deserialize(stream, defaultResolver); + } + + public static object Deserialize(Stream stream, bool readStrict) + { + return MessagePackSerializer.Deserialize(stream, defaultResolver, readStrict); + } + + public static System.Threading.Tasks.Task DeserializeAsync(Stream stream) + { + return MessagePackSerializer.DeserializeAsync(stream, defaultResolver); + } + + class CompositeResolver : IFormatterResolver + { + public static readonly CompositeResolver Instance = new CompositeResolver(); + + static bool isFreezed = false; + static IFormatterResolver[] resolvers = new IFormatterResolver[0]; + + CompositeResolver() + { + } + + public static void Register(params IFormatterResolver[] resolvers) + { + if (isFreezed) + { + throw new InvalidOperationException("Register must call on startup(before use GetFormatter)."); + } + + CompositeResolver.resolvers = resolvers; + } + + public IMessagePackFormatter GetFormatter() + { + return FormatterCache.formatter; + } + + static class FormatterCache + { + public static readonly IMessagePackFormatter formatter; + + static FormatterCache() + { + isFreezed = true; + + foreach (var item in resolvers) + { + var f = item.GetFormatter(); + if (f != null) + { + formatter = f; + return; + } + } + } + } + } + } + } +} + +#endif \ No newline at end of file diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/MessagePackSerializer.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/MessagePackSerializer.cs index 1b7b6c19b..0d73a67f3 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/MessagePackSerializer.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/MessagePackSerializer.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 using Datadog.Trace.Vendors.MessagePack.Internal; using System; using System.IO; @@ -131,7 +132,7 @@ public static int Serialize(ref byte[] bytes, int offset, T value, IFormatter return resolver.GetFormatterWithVerify().Serialize(ref bytes, offset, value, resolver); } -#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +#if NETSTANDARD || NETFRAMEWORK /// /// Serialize to stream(async). @@ -258,7 +259,7 @@ public static T Deserialize(byte[] bytes, int offset, IFormatterResolver reso return resolver.GetFormatterWithVerify().Deserialize(bytes, offset, resolver, out readSize); } -#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +#if NETSTANDARD || NETFRAMEWORK public static System.Threading.Tasks.Task DeserializeAsync(Stream stream) { diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Nil.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Nil.cs index b7ab5e680..c53e38afd 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/Nil.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Nil.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 using System; namespace Datadog.Trace.Vendors.MessagePack diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/AttributeFormatterResolver.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/AttributeFormatterResolver.cs index 1e652e383..cb4361e7c 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/AttributeFormatterResolver.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/AttributeFormatterResolver.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 using Datadog.Trace.Vendors.MessagePack.Formatters; using System; using System.Reflection; diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/BuiltinResolver.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/BuiltinResolver.cs index 85a61a80d..74379f069 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/BuiltinResolver.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/BuiltinResolver.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 using Datadog.Trace.Vendors.MessagePack.Formatters; using Datadog.Trace.Vendors.MessagePack.Internal; using Datadog.Trace.Vendors.MessagePack.Resolvers; @@ -132,7 +133,7 @@ internal static class BuiltinResolverGetFormatterHelper { typeof(ArraySegment), ByteArraySegmentFormatter.Instance }, { typeof(ArraySegment?),new StaticNullableFormatter>(ByteArraySegmentFormatter.Instance) }, -#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +#if NETSTANDARD || NETFRAMEWORK {typeof(System.Numerics.BigInteger), BigIntegerFormatter.Instance}, {typeof(System.Numerics.BigInteger?), new StaticNullableFormatter(BigIntegerFormatter.Instance)}, {typeof(System.Numerics.Complex), ComplexFormatter.Instance}, diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/CompositeResolver.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/CompositeResolver.cs index b95055810..01795fe6a 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/CompositeResolver.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/CompositeResolver.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 using Datadog.Trace.Vendors.MessagePack.Formatters; using System; using System.Reflection; diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/ContractlessReflectionObjectResolver.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/ContractlessReflectionObjectResolver.cs index 78697eff4..7388186da 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/ContractlessReflectionObjectResolver.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/ContractlessReflectionObjectResolver.cs @@ -2,7 +2,8 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ -#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 +#if NETSTANDARD || NETFRAMEWORK using Datadog.Trace.Vendors.MessagePack.Formatters; using Datadog.Trace.Vendors.MessagePack.Internal; diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/DynamicEnumAsStringResolver.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/DynamicEnumAsStringResolver.cs index 3626d57ef..dd13399ff 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/DynamicEnumAsStringResolver.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/DynamicEnumAsStringResolver.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 #if !UNITY_WSA using Datadog.Trace.Vendors.MessagePack.Formatters; diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/DynamicEnumResolver.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/DynamicEnumResolver.cs new file mode 100644 index 000000000..7d941ae0e --- /dev/null +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/DynamicEnumResolver.cs @@ -0,0 +1,129 @@ +//------------------------------------------------------------------------------ +// +// This file was automatically generated by the UpdateVendors tool. +//------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 +#if !UNITY_WSA +#if !NET_STANDARD_2_0 + +using System; +using Datadog.Trace.Vendors.MessagePack.Formatters; +using Datadog.Trace.Vendors.MessagePack.Internal; +using System.Reflection; +using System.Reflection.Emit; +using System.Threading; + +namespace Datadog.Trace.Vendors.MessagePack.Resolvers +{ + /// + /// EnumResolver by dynamic code generation, serialized underlying type. + /// + internal sealed class DynamicEnumResolver : IFormatterResolver + { + public static readonly DynamicEnumResolver Instance = new DynamicEnumResolver(); + + const string ModuleName = "MessagePack.Resolvers.DynamicEnumResolver"; + + static readonly DynamicAssembly assembly; + + static int nameSequence = 0; + + DynamicEnumResolver() + { + + } + + static DynamicEnumResolver() + { + assembly = new DynamicAssembly(ModuleName); + } + + +#if NETFRAMEWORK + public AssemblyBuilder Save() + { + return assembly.Save(); + } +#endif + + public IMessagePackFormatter GetFormatter() + { + return FormatterCache.formatter; + } + + static class FormatterCache + { + public static readonly IMessagePackFormatter formatter; + + static FormatterCache() + { + var ti = typeof(T).GetTypeInfo(); + if (ti.IsNullable()) + { + // build underlying type and use wrapped formatter. + ti = ti.GenericTypeArguments[0].GetTypeInfo(); + if (!ti.IsEnum) + { + return; + } + + var innerFormatter = DynamicEnumResolver.Instance.GetFormatterDynamic(ti.AsType()); + if (innerFormatter == null) + { + return; + } + formatter = (IMessagePackFormatter)Activator.CreateInstance(typeof(StaticNullableFormatter<>).MakeGenericType(ti.AsType()), new object[] { innerFormatter }); + return; + } + else if (!ti.IsEnum) + { + return; + } + + var formatterTypeInfo = BuildType(typeof(T)); + formatter = (IMessagePackFormatter)Activator.CreateInstance(formatterTypeInfo.AsType()); + } + } + + static TypeInfo BuildType(Type enumType) + { + var underlyingType = Enum.GetUnderlyingType(enumType); + var formatterType = typeof(IMessagePackFormatter<>).MakeGenericType(enumType); + + var typeBuilder = assembly.DefineType("MessagePack.Formatters." + enumType.FullName.Replace(".", "_") + "Formatter" + Interlocked.Increment(ref nameSequence), TypeAttributes.Public | TypeAttributes.Sealed, null, new[] { formatterType }); + + // int Serialize(ref byte[] bytes, int offset, T value, IFormatterResolver formatterResolver); + { + var method = typeBuilder.DefineMethod("Serialize", MethodAttributes.Public | MethodAttributes.Final | MethodAttributes.Virtual, + typeof(int), + new Type[] { typeof(byte[]).MakeByRefType(), typeof(int), enumType, typeof(IFormatterResolver) }); + + var il = method.GetILGenerator(); + il.Emit(OpCodes.Ldarg_1); + il.Emit(OpCodes.Ldarg_2); + il.Emit(OpCodes.Ldarg_3); + il.Emit(OpCodes.Call, typeof(MessagePackBinary).GetRuntimeMethod("Write" + underlyingType.Name, new[] { typeof(byte[]).MakeByRefType(), typeof(int), underlyingType })); + il.Emit(OpCodes.Ret); + } + + // T Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize); + { + var method = typeBuilder.DefineMethod("Deserialize", MethodAttributes.Public | MethodAttributes.Final | MethodAttributes.Virtual, + enumType, + new Type[] { typeof(byte[]), typeof(int), typeof(IFormatterResolver), typeof(int).MakeByRefType() }); + + var il = method.GetILGenerator(); + il.Emit(OpCodes.Ldarg_1); + il.Emit(OpCodes.Ldarg_2); + il.Emit(OpCodes.Ldarg_S, (byte)4); + il.Emit(OpCodes.Call, typeof(MessagePackBinary).GetRuntimeMethod("Read" + underlyingType.Name, new[] { typeof(byte[]), typeof(int), typeof(int).MakeByRefType() })); + il.Emit(OpCodes.Ret); + } + + return typeBuilder.CreateTypeInfo(); + } + } +} + +#endif +#endif \ No newline at end of file diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/DynamicGenericResolver.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/DynamicGenericResolver.cs index 51267a250..ec267f3c2 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/DynamicGenericResolver.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/DynamicGenericResolver.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 #if !UNITY_WSA using Datadog.Trace.Vendors.MessagePack.Formatters; @@ -13,7 +14,7 @@ using System.Collections.ObjectModel; using System.Collections; -#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +#if NETSTANDARD || NETFRAMEWORK using System.Threading.Tasks; #endif @@ -66,7 +67,7 @@ internal static class DynamicGenericResolverGetFormatterHelper {typeof(SortedList<,>), typeof(SortedListFormatter<,>)}, {typeof(ILookup<,>), typeof(InterfaceLookupFormatter<,>)}, {typeof(IGrouping<,>), typeof(InterfaceGroupingFormatter<,>)}, -#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +#if NETSTANDARD || NETFRAMEWORK {typeof(ObservableCollection<>), typeof(ObservableCollectionFormatter<>)}, {typeof(ReadOnlyObservableCollection<>),(typeof(ReadOnlyObservableCollectionFormatter<>))}, {typeof(IReadOnlyList<>), typeof(InterfaceReadOnlyListFormatter<>)}, @@ -128,16 +129,25 @@ internal static object GetFormatter(Type t) { return CreateInstance(typeof(KeyValuePairFormatter<,>), ti.GenericTypeArguments); } - else if (isNullable && nullableElementType.GetTypeInfo().IsConstructedGenericType() && nullableElementType.GetGenericTypeDefinition() == typeof(KeyValuePair<,>)) + else if (isNullable && nullableElementType.IsConstructedGenericType && nullableElementType.GetGenericTypeDefinition() == typeof(KeyValuePair<,>)) { return CreateInstance(typeof(NullableFormatter<>), new[] { nullableElementType }); } -#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +#if NETSTANDARD || NETFRAMEWORK +#if NETCOREAPP // ValueTask - // Deleted, unneeded for Datadog.Trace + else if (genericType == typeof(ValueTask<>)) + { + return CreateInstance(typeof(ValueTaskFormatter<>), ti.GenericTypeArguments); + } + else if (isNullable && nullableElementType.IsConstructedGenericType && nullableElementType.GetGenericTypeDefinition() == typeof(ValueTask<>)) + { + return CreateInstance(typeof(NullableFormatter<>), new[] { nullableElementType }); + } +#endif // Tuple else if (ti.FullName.StartsWith("System.Tuple")) { @@ -175,12 +185,48 @@ internal static object GetFormatter(Type t) return CreateInstance(tupleFormatterType, ti.GenericTypeArguments); } +#if NETCOREAPP // ValueTuple - // Deleted, unneeded for Datadog.Trace + else if (ti.FullName.StartsWith("System.ValueTuple")) + { + Type tupleFormatterType = null; + switch (ti.GenericTypeArguments.Length) + { + case 1: + tupleFormatterType = typeof(ValueTupleFormatter<>); + break; + case 2: + tupleFormatterType = typeof(ValueTupleFormatter<,>); + break; + case 3: + tupleFormatterType = typeof(ValueTupleFormatter<,,>); + break; + case 4: + tupleFormatterType = typeof(ValueTupleFormatter<,,,>); + break; + case 5: + tupleFormatterType = typeof(ValueTupleFormatter<,,,,>); + break; + case 6: + tupleFormatterType = typeof(ValueTupleFormatter<,,,,,>); + break; + case 7: + tupleFormatterType = typeof(ValueTupleFormatter<,,,,,,>); + break; + case 8: + tupleFormatterType = typeof(ValueTupleFormatter<,,,,,,,>); + break; + default: + break; + } + + return CreateInstance(tupleFormatterType, ti.GenericTypeArguments); + } #endif - // ArraySegement +#endif + // ArraySegment else if (genericType == typeof(ArraySegment<>)) { if (ti.GenericTypeArguments[0] == typeof(byte)) @@ -192,7 +238,7 @@ internal static object GetFormatter(Type t) return CreateInstance(typeof(ArraySegmentFormatter<>), ti.GenericTypeArguments); } } - else if (isNullable && nullableElementType.GetTypeInfo().IsConstructedGenericType() && nullableElementType.GetGenericTypeDefinition() == typeof(ArraySegment<>)) + else if (isNullable && nullableElementType.IsConstructedGenericType && nullableElementType.GetGenericTypeDefinition() == typeof(ArraySegment<>)) { if (nullableElementType == typeof(ArraySegment)) { @@ -215,7 +261,7 @@ internal static object GetFormatter(Type t) // generic collection else if (ti.GenericTypeArguments.Length == 1 - && ti.ImplementedInterfaces.Any(x => x.GetTypeInfo().IsConstructedGenericType() && x.GetGenericTypeDefinition() == typeof(ICollection<>)) + && ti.ImplementedInterfaces.Any(x => x.IsConstructedGenericType && x.GetGenericTypeDefinition() == typeof(ICollection<>)) && ti.DeclaredConstructors.Any(x => x.GetParameters().Length == 0)) { var elemType = ti.GenericTypeArguments[0]; @@ -223,7 +269,7 @@ internal static object GetFormatter(Type t) } // generic dictionary else if (ti.GenericTypeArguments.Length == 2 - && ti.ImplementedInterfaces.Any(x => x.GetTypeInfo().IsConstructedGenericType() && x.GetGenericTypeDefinition() == typeof(IDictionary<,>)) + && ti.ImplementedInterfaces.Any(x => x.IsConstructedGenericType && x.GetGenericTypeDefinition() == typeof(IDictionary<,>)) && ti.DeclaredConstructors.Any(x => x.GetParameters().Length == 0)) { var keyType = ti.GenericTypeArguments[0]; @@ -263,4 +309,4 @@ static object CreateInstance(Type genericType, Type[] genericTypeArguments, para } } -#endif +#endif \ No newline at end of file diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/DynamicObjectResolver.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/DynamicObjectResolver.cs new file mode 100644 index 000000000..d263350cb --- /dev/null +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/DynamicObjectResolver.cs @@ -0,0 +1,1870 @@ +//------------------------------------------------------------------------------ +// +// This file was automatically generated by the UpdateVendors tool. +//------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 +#if !UNITY_WSA +#if !NET_STANDARD_2_0 + +using System; +using System.Linq; +using Datadog.Trace.Vendors.MessagePack.Formatters; +using Datadog.Trace.Vendors.MessagePack.Internal; +using System.Reflection; +using System.Reflection.Emit; +using System.Collections.Generic; +using System.Text.RegularExpressions; +using System.Runtime.Serialization; +using System.Text; +using System.Threading; + +namespace Datadog.Trace.Vendors.MessagePack.Resolvers +{ + /// + /// ObjectResolver by dynamic code generation. + /// + internal sealed class DynamicObjectResolver : IFormatterResolver + { + public static readonly DynamicObjectResolver Instance = new DynamicObjectResolver(); + + const string ModuleName = "MessagePack.Resolvers.DynamicObjectResolver"; + + internal static readonly DynamicAssembly assembly; + + DynamicObjectResolver() + { + + } + + static DynamicObjectResolver() + { + assembly = new DynamicAssembly(ModuleName); + } + +#if NETFRAMEWORK + public AssemblyBuilder Save() + { + return assembly.Save(); + } +#endif + + public IMessagePackFormatter GetFormatter() + { + return FormatterCache.formatter; + } + + static class FormatterCache + { + public static readonly IMessagePackFormatter formatter; + + static FormatterCache() + { + var ti = typeof(T).GetTypeInfo(); + + if (ti.IsInterface) + { + return; + } + + if (ti.IsNullable()) + { + ti = ti.GenericTypeArguments[0].GetTypeInfo(); + + var innerFormatter = DynamicObjectResolver.Instance.GetFormatterDynamic(ti.AsType()); + if (innerFormatter == null) + { + return; + } + formatter = (IMessagePackFormatter)Activator.CreateInstance(typeof(StaticNullableFormatter<>).MakeGenericType(ti.AsType()), new object[] { innerFormatter }); + return; + } + + if (ti.IsAnonymous()) + { + formatter = (IMessagePackFormatter)DynamicObjectTypeBuilder.BuildFormatterToDynamicMethod(typeof(T), true, true, false); + return; + } + + var formatterTypeInfo = DynamicObjectTypeBuilder.BuildType(assembly, typeof(T), false, false); + if (formatterTypeInfo == null) return; + + formatter = (IMessagePackFormatter)Activator.CreateInstance(formatterTypeInfo.AsType()); + } + } + } + + /// + /// ObjectResolver by dynamic code generation, allow private member. + /// + internal sealed class DynamicObjectResolverAllowPrivate : IFormatterResolver + { + public static readonly DynamicObjectResolverAllowPrivate Instance = new DynamicObjectResolverAllowPrivate(); + + DynamicObjectResolverAllowPrivate() + { + + } + + public IMessagePackFormatter GetFormatter() + { + return FormatterCache.formatter; + } + + static class FormatterCache + { + public static readonly IMessagePackFormatter formatter; + + static FormatterCache() + { + var ti = typeof(T).GetTypeInfo(); + + if (ti.IsInterface) + { + return; + } + + if (ti.IsNullable()) + { + ti = ti.GenericTypeArguments[0].GetTypeInfo(); + + var innerFormatter = DynamicObjectResolverAllowPrivate.Instance.GetFormatterDynamic(ti.AsType()); + if (innerFormatter == null) + { + return; + } + formatter = (IMessagePackFormatter)Activator.CreateInstance(typeof(StaticNullableFormatter<>).MakeGenericType(ti.AsType()), new object[] { innerFormatter }); + return; + } + + if (ti.IsAnonymous()) + { + formatter = (IMessagePackFormatter)DynamicObjectTypeBuilder.BuildFormatterToDynamicMethod(typeof(T), true, true, false); + } + else + { + formatter = (IMessagePackFormatter)DynamicObjectTypeBuilder.BuildFormatterToDynamicMethod(typeof(T), false, false, true); + } + } + } + } + + /// + /// ObjectResolver by dynamic code generation, no needs MessagePackObject attribute and serialized key as string. + /// + internal sealed class DynamicContractlessObjectResolver : IFormatterResolver + { + public static readonly DynamicContractlessObjectResolver Instance = new DynamicContractlessObjectResolver(); + + const string ModuleName = "MessagePack.Resolvers.DynamicContractlessObjectResolver"; + + static readonly DynamicAssembly assembly; + + DynamicContractlessObjectResolver() + { + + } + + static DynamicContractlessObjectResolver() + { + assembly = new DynamicAssembly(ModuleName); + } + +#if NETFRAMEWORK + public AssemblyBuilder Save() + { + return assembly.Save(); + } +#endif + + public IMessagePackFormatter GetFormatter() + { + return FormatterCache.formatter; + } + + static class FormatterCache + { + public static readonly IMessagePackFormatter formatter; + + static FormatterCache() + { + if (typeof(T) == typeof(object)) + { + return; + } + + var ti = typeof(T).GetTypeInfo(); + + if (ti.IsInterface) + { + return; + } + + if (ti.IsNullable()) + { + ti = ti.GenericTypeArguments[0].GetTypeInfo(); + + var innerFormatter = DynamicContractlessObjectResolver.Instance.GetFormatterDynamic(ti.AsType()); + if (innerFormatter == null) + { + return; + } + formatter = (IMessagePackFormatter)Activator.CreateInstance(typeof(StaticNullableFormatter<>).MakeGenericType(ti.AsType()), new object[] { innerFormatter }); + return; + } + + if (ti.IsAnonymous()) + { + formatter = (IMessagePackFormatter)DynamicObjectTypeBuilder.BuildFormatterToDynamicMethod(typeof(T), true, true, false); + return; + } + + var formatterTypeInfo = DynamicObjectTypeBuilder.BuildType(assembly, typeof(T), true, true); + if (formatterTypeInfo == null) return; + + formatter = (IMessagePackFormatter)Activator.CreateInstance(formatterTypeInfo.AsType()); + } + } + } + + /// + /// ObjectResolver by dynamic code generation, no needs MessagePackObject attribute and serialized key as string, allow private member. + /// + internal sealed class DynamicContractlessObjectResolverAllowPrivate : IFormatterResolver + { + public static readonly DynamicContractlessObjectResolverAllowPrivate Instance = new DynamicContractlessObjectResolverAllowPrivate(); + + public IMessagePackFormatter GetFormatter() + { + return FormatterCache.formatter; + } + + static class FormatterCache + { + public static readonly IMessagePackFormatter formatter; + + static FormatterCache() + { + if (typeof(T) == typeof(object)) + { + return; + } + + var ti = typeof(T).GetTypeInfo(); + + if (ti.IsInterface) + { + return; + } + + if (ti.IsNullable()) + { + ti = ti.GenericTypeArguments[0].GetTypeInfo(); + + var innerFormatter = DynamicContractlessObjectResolverAllowPrivate.Instance.GetFormatterDynamic(ti.AsType()); + if (innerFormatter == null) + { + return; + } + formatter = (IMessagePackFormatter)Activator.CreateInstance(typeof(StaticNullableFormatter<>).MakeGenericType(ti.AsType()), new object[] { innerFormatter }); + return; + } + + if (ti.IsAnonymous()) + { + formatter = (IMessagePackFormatter)DynamicObjectTypeBuilder.BuildFormatterToDynamicMethod(typeof(T), true, true, false); + } + else + { + formatter = (IMessagePackFormatter)DynamicObjectTypeBuilder.BuildFormatterToDynamicMethod(typeof(T), true, true, true); + } + } + } + } +} + +namespace Datadog.Trace.Vendors.MessagePack.Internal +{ + internal static class DynamicObjectTypeBuilder + { +#if NETSTANDARD || NETFRAMEWORK + static readonly Regex SubtractFullNameRegex = new Regex(@", Version=\d+.\d+.\d+.\d+, Culture=\w+, PublicKeyToken=\w+", RegexOptions.Compiled); +#else + static readonly Regex SubtractFullNameRegex = new Regex(@", Version=\d+.\d+.\d+.\d+, Culture=\w+, PublicKeyToken=\w+"); +#endif + + static int nameSequence = 0; + + static HashSet ignoreTypes = new HashSet + { + {typeof(object)}, + {typeof(short)}, + {typeof(int)}, + {typeof(long)}, + {typeof(ushort)}, + {typeof(uint)}, + {typeof(ulong)}, + {typeof(float)}, + {typeof(double)}, + {typeof(bool)}, + {typeof(byte)}, + {typeof(sbyte)}, + {typeof(decimal)}, + {typeof(char)}, + {typeof(string)}, + {typeof(System.Guid)}, + {typeof(System.TimeSpan)}, + {typeof(System.DateTime)}, + {typeof(System.DateTimeOffset)}, + {typeof(MessagePack.Nil)}, + }; + + public static TypeInfo BuildType(DynamicAssembly assembly, Type type, bool forceStringKey, bool contractless) + { + if (ignoreTypes.Contains(type)) return null; + + var serializationInfo = MessagePack.Internal.ObjectSerializationInfo.CreateOrNull(type, forceStringKey, contractless, false); + if (serializationInfo == null) return null; + + var formatterType = typeof(IMessagePackFormatter<>).MakeGenericType(type); + var typeBuilder = assembly.DefineType("MessagePack.Formatters." + SubtractFullNameRegex.Replace(type.FullName, "").Replace(".", "_") + "Formatter" + Interlocked.Increment(ref nameSequence), TypeAttributes.Public | TypeAttributes.Sealed, null, new[] { formatterType }); + + FieldBuilder stringByteKeysField = null; + Dictionary customFormatterLookup = null; + + // string key needs string->int mapper for deserialize switch statement + if (serializationInfo.IsStringKey) + { + var method = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, Type.EmptyTypes); + stringByteKeysField = typeBuilder.DefineField("stringByteKeys", typeof(byte[][]), FieldAttributes.Private | FieldAttributes.InitOnly); + + var il = method.GetILGenerator(); + BuildConstructor(type, serializationInfo, method, stringByteKeysField, il); + customFormatterLookup = BuildCustomFormatterField(typeBuilder, serializationInfo, il); + il.Emit(OpCodes.Ret); + } + else + { + var method = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, Type.EmptyTypes); + var il = method.GetILGenerator(); + il.EmitLoadThis(); + il.Emit(OpCodes.Call, objectCtor); + customFormatterLookup = BuildCustomFormatterField(typeBuilder, serializationInfo, il); + il.Emit(OpCodes.Ret); + } + + { + var method = typeBuilder.DefineMethod("Serialize", MethodAttributes.Public | MethodAttributes.Final | MethodAttributes.Virtual, + typeof(int), + new Type[] { typeof(byte[]).MakeByRefType(), typeof(int), type, typeof(IFormatterResolver) }); + + var il = method.GetILGenerator(); + BuildSerialize(type, serializationInfo, il, () => + { + il.EmitLoadThis(); + il.EmitLdfld(stringByteKeysField); + }, (index, member) => + { + FieldInfo fi; + if (!customFormatterLookup.TryGetValue(member, out fi)) return null; + + return () => + { + il.EmitLoadThis(); + il.EmitLdfld(fi); + }; + }, 1); + } + + { + var method = typeBuilder.DefineMethod("Deserialize", MethodAttributes.Public | MethodAttributes.Final | MethodAttributes.Virtual, + type, + new Type[] { typeof(byte[]), typeof(int), typeof(IFormatterResolver), typeof(int).MakeByRefType() }); + + var il = method.GetILGenerator(); + BuildDeserialize(type, serializationInfo, il, (index, member) => + { + FieldInfo fi; + if (!customFormatterLookup.TryGetValue(member, out fi)) return null; + + return () => + { + il.EmitLoadThis(); + il.EmitLdfld(fi); + }; + }, 1); // firstArgIndex:0 is this. + } + + return typeBuilder.CreateTypeInfo(); + } + + public static object BuildFormatterToDynamicMethod(Type type, bool forceStringKey, bool contractless, bool allowPrivate) + { + var serializationInfo = ObjectSerializationInfo.CreateOrNull(type, forceStringKey, contractless, allowPrivate); + if (serializationInfo == null) return null; + + // internal delegate int AnonymousSerializeFunc(byte[][] stringByteKeysField, object[] customFormatters, ref byte[] bytes, int offset, T value, IFormatterResolver resolver); + // internal delegate T AnonymousDeserializeFunc(object[] customFormatters, byte[] bytes, int offset, IFormatterResolver resolver, out int readSize); + var serialize = new DynamicMethod("Serialize", typeof(int), new[] { typeof(byte[][]), typeof(object[]), typeof(byte[]).MakeByRefType(), typeof(int), type, typeof(IFormatterResolver) }, type, true); + DynamicMethod deserialize = null; + + List stringByteKeysField = new List(); + List serializeCustomFormatters = new List(); + List deserializeCustomFormatters = new List(); + + if (serializationInfo.IsStringKey) + { + var i = 0; + foreach (var item in serializationInfo.Members.Where(x => x.IsReadable)) + { + stringByteKeysField.Add(MessagePackBinary.GetEncodedStringBytes(item.StringKey)); + i++; + } + } + foreach (var item in serializationInfo.Members.Where(x => x.IsReadable)) + { + var attr = item.GetMessagePackFormatterAttribute(); + if (attr != null) + { + var formatter = Activator.CreateInstance(attr.FormatterType, attr.Arguments); + serializeCustomFormatters.Add(formatter); + } + else + { + serializeCustomFormatters.Add(null); + } + } + foreach (var item in serializationInfo.Members) // not only for writable because for use ctor. + { + var attr = item.GetMessagePackFormatterAttribute(); + if (attr != null) + { + var formatter = Activator.CreateInstance(attr.FormatterType, attr.Arguments); + deserializeCustomFormatters.Add(formatter); + } + else + { + deserializeCustomFormatters.Add(null); + } + } + + { + var il = serialize.GetILGenerator(); + BuildSerialize(type, serializationInfo, il, () => + { + il.EmitLdarg(0); + }, (index, member) => + { + if (serializeCustomFormatters.Count == 0) return null; + if (serializeCustomFormatters[index] == null) return null; + + return () => + { + il.EmitLdarg(1); // read object[] + il.EmitLdc_I4(index); + il.Emit(OpCodes.Ldelem_Ref); // object + il.Emit(OpCodes.Castclass, serializeCustomFormatters[index].GetType()); + }; + }, 2); // 0, 1 is parameter. + } + + if (serializationInfo.IsStruct || serializationInfo.BestmatchConstructor != null) + { + deserialize = new DynamicMethod("Deserialize", type, new[] { typeof(object[]), typeof(byte[]), typeof(int), typeof(IFormatterResolver), typeof(int).MakeByRefType() }, type, true); + + var il = deserialize.GetILGenerator(); + BuildDeserialize(type, serializationInfo, il, (index, member) => + { + if (deserializeCustomFormatters.Count == 0) return null; + if (deserializeCustomFormatters[index] == null) return null; + + return () => + { + il.EmitLdarg(0); // read object[] + il.EmitLdc_I4(index); + il.Emit(OpCodes.Ldelem_Ref); // object + il.Emit(OpCodes.Castclass, deserializeCustomFormatters[index].GetType()); + }; + }, 1); + } + + object serializeDelegate = serialize.CreateDelegate(typeof(AnonymousSerializeFunc<>).MakeGenericType(type)); + object deserializeDelegate = (deserialize == null) + ? (object)null + : (object)deserialize.CreateDelegate(typeof(AnonymousDeserializeFunc<>).MakeGenericType(type)); + var resultFormatter = Activator.CreateInstance(typeof(AnonymousSerializableFormatter<>).MakeGenericType(type), + new[] { stringByteKeysField.ToArray(), serializeCustomFormatters.ToArray(), deserializeCustomFormatters.ToArray(), serializeDelegate, deserializeDelegate }); + return resultFormatter; + } + + static void BuildConstructor(Type type, ObjectSerializationInfo info, ConstructorInfo method, FieldBuilder stringByteKeysField, ILGenerator il) + { + il.EmitLoadThis(); + il.Emit(OpCodes.Call, objectCtor); + + var writeCount = info.Members.Count(x => x.IsReadable); + il.EmitLoadThis(); + il.EmitLdc_I4(writeCount); + il.Emit(OpCodes.Newarr, typeof(byte[])); + + var i = 0; + foreach (var item in info.Members.Where(x => x.IsReadable)) + { + il.Emit(OpCodes.Dup); + il.EmitLdc_I4(i); + il.Emit(OpCodes.Ldstr, item.StringKey); + il.EmitCall(MessagePackBinaryTypeInfo.GetEncodedStringBytes); + il.Emit(OpCodes.Stelem_Ref); + i++; + } + + il.Emit(OpCodes.Stfld, stringByteKeysField); + } + + static Dictionary BuildCustomFormatterField(TypeBuilder builder, ObjectSerializationInfo info, ILGenerator il) + { + Dictionary dict = new Dictionary(); + foreach (var item in info.Members.Where(x => x.IsReadable || x.IsWritable)) + { + var attr = item.GetMessagePackFormatterAttribute(); + if (attr != null) + { + var f = builder.DefineField(item.Name + "_formatter", attr.FormatterType, FieldAttributes.Private | FieldAttributes.InitOnly); + + var bindingFlags = (int)(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); + + var attrVar = il.DeclareLocal(typeof(MessagePackFormatterAttribute)); + + il.Emit(OpCodes.Ldtoken, info.Type); + il.EmitCall(EmitInfo.GetTypeFromHandle); + il.Emit(OpCodes.Ldstr, item.Name); + il.EmitLdc_I4(bindingFlags); + if (item.IsProperty) + { + il.EmitCall(EmitInfo.TypeGetProperty); + } + else + { + il.EmitCall(EmitInfo.TypeGetField); + } + + il.EmitTrue(); + il.EmitCall(EmitInfo.GetCustomAttributeMessagePackFormatterAttribute); + il.EmitStloc(attrVar); + + il.EmitLoadThis(); + + il.EmitLdloc(attrVar); + il.EmitCall(EmitInfo.MessagePackFormatterAttr.FormatterType); + il.EmitLdloc(attrVar); + il.EmitCall(EmitInfo.MessagePackFormatterAttr.Arguments); + il.EmitCall(EmitInfo.ActivatorCreateInstance); + + il.Emit(OpCodes.Castclass, attr.FormatterType); + il.Emit(OpCodes.Stfld, f); + + dict.Add(item, f); + } + } + + return dict; + } + + // int Serialize([arg:1]ref byte[] bytes, [arg:2]int offset, [arg:3]T value, [arg:4]IFormatterResolver formatterResolver); + static void BuildSerialize(Type type, ObjectSerializationInfo info, ILGenerator il, Action emitStringByteKeys, Func tryEmitLoadCustomFormatter, int firstArgIndex) + { + var argBytes = new ArgumentField(il, firstArgIndex); + var argOffset = new ArgumentField(il, firstArgIndex + 1); + var argValue = new ArgumentField(il, firstArgIndex + 2, type); + var argResolver = new ArgumentField(il, firstArgIndex + 3); + + // if(value == null) return WriteNil + if (type.GetTypeInfo().IsClass) + { + var elseBody = il.DefineLabel(); + + argValue.EmitLoad(); + il.Emit(OpCodes.Brtrue_S, elseBody); + argBytes.EmitLoad(); + argOffset.EmitLoad(); + il.EmitCall(MessagePackBinaryTypeInfo.WriteNil); + il.Emit(OpCodes.Ret); + + il.MarkLabel(elseBody); + } + + // IMessagePackSerializationCallbackReceiver.OnBeforeSerialize() + if (type.GetTypeInfo().ImplementedInterfaces.Any(x => x == typeof(IMessagePackSerializationCallbackReceiver))) + { + // call directly + var runtimeMethods = type.GetRuntimeMethods().Where(x => x.Name == "OnBeforeSerialize").ToArray(); + if (runtimeMethods.Length == 1) + { + argValue.EmitLoad(); + il.Emit(OpCodes.Call, runtimeMethods[0]); // don't use EmitCall helper(must use 'Call') + } + else + { + argValue.EmitLdarg(); // force ldarg + il.EmitBoxOrDoNothing(type); + il.EmitCall(onBeforeSerialize); + } + } + + // var startOffset = offset; + var startOffsetLocal = il.DeclareLocal(typeof(int)); // [loc:0] + argOffset.EmitLoad(); + il.EmitStloc(startOffsetLocal); + + if (info.IsIntKey) + { + // use Array + var maxKey = info.Members.Where(x => x.IsReadable).Select(x => x.IntKey).DefaultIfEmpty(-1).Max(); + var intKeyMap = info.Members.Where(x => x.IsReadable).ToDictionary(x => x.IntKey); + + EmitOffsetPlusEqual(il, null, () => + { + var len = maxKey + 1; + il.EmitLdc_I4(len); + if (len <= MessagePackRange.MaxFixArrayCount) + { + il.EmitCall(MessagePackBinaryTypeInfo.WriteFixedArrayHeaderUnsafe); + } + else + { + il.EmitCall(MessagePackBinaryTypeInfo.WriteArrayHeader); + } + }, argBytes, argOffset); + + for (int i = 0; i <= maxKey; i++) + { + ObjectSerializationInfo.EmittableMember member; + if (intKeyMap.TryGetValue(i, out member)) + { + // offset += serialzie + EmitSerializeValue(il, type.GetTypeInfo(), member, i, tryEmitLoadCustomFormatter, argBytes, argOffset, argValue, argResolver); + } + else + { + // Write Nil as Blanc + EmitOffsetPlusEqual(il, null, () => + { + il.EmitCall(MessagePackBinaryTypeInfo.WriteNil); + }, argBytes, argOffset); + } + } + } + else + { + // use Map + var writeCount = info.Members.Count(x => x.IsReadable); + + EmitOffsetPlusEqual(il, null, () => + { + il.EmitLdc_I4(writeCount); + if (writeCount <= MessagePackRange.MaxFixMapCount) + { + il.EmitCall(MessagePackBinaryTypeInfo.WriteFixedMapHeaderUnsafe); + } + else + { + il.EmitCall(MessagePackBinaryTypeInfo.WriteMapHeader); + } + }, argBytes, argOffset); + + var index = 0; + foreach (var item in info.Members.Where(x => x.IsReadable)) + { + // offset += writekey + EmitOffsetPlusEqual(il, null, () => + { + emitStringByteKeys(); + il.EmitLdc_I4(index); + il.Emit(OpCodes.Ldelem_Ref); + + // Optimize, WriteRaw(Unity, large) or UnsafeMemory32/64.WriteRawX +#if NETSTANDARD || NETFRAMEWORK + var valueLen = MessagePackBinary.GetEncodedStringBytes(item.StringKey).Length; + if (valueLen <= MessagePackRange.MaxFixStringLength) + { + if (UnsafeMemory.Is32Bit) + { + il.EmitCall(typeof(UnsafeMemory32).GetRuntimeMethod("WriteRaw" + valueLen, new[] { refByte, typeof(int), typeof(byte[]) })); + } + else + { + il.EmitCall(typeof(UnsafeMemory64).GetRuntimeMethod("WriteRaw" + valueLen, new[] { refByte, typeof(int), typeof(byte[]) })); + } + } + else +#endif + { + il.EmitCall(MessagePackBinaryTypeInfo.WriteRaw); + } + }, argBytes, argOffset); + + // offset += serialzie + EmitSerializeValue(il, type.GetTypeInfo(), item, index, tryEmitLoadCustomFormatter, argBytes, argOffset, argValue, argResolver); + index++; + } + } + + // return startOffset- offset; + argOffset.EmitLoad(); + il.EmitLdloc(startOffsetLocal); + il.Emit(OpCodes.Sub); + il.Emit(OpCodes.Ret); + } + + // offset += ***(ref bytes, offset.... + static void EmitOffsetPlusEqual(ILGenerator il, Action loadEmit, Action emit, ArgumentField argBytes, ArgumentField argOffset) + { + argOffset.EmitLoad(); + + if (loadEmit != null) loadEmit(); + + argBytes.EmitLoad(); + argOffset.EmitLoad(); + + emit(); + + il.Emit(OpCodes.Add); + argOffset.EmitStore(); + } + + static void EmitSerializeValue(ILGenerator il, TypeInfo type, ObjectSerializationInfo.EmittableMember member, int index, Func tryEmitLoadCustomFormatter, ArgumentField argBytes, ArgumentField argOffset, ArgumentField argValue, ArgumentField argResolver) + { + var t = member.Type; + var emitter = tryEmitLoadCustomFormatter(index, member); + if (emitter != null) + { + EmitOffsetPlusEqual(il, () => + { + emitter(); + }, () => + { + argValue.EmitLoad(); + member.EmitLoadValue(il); + argResolver.EmitLoad(); + il.EmitCall(typeof(IMessagePackFormatter<>).MakeGenericType(t).GetRuntimeMethod("Serialize", new[] { refByte, typeof(int), t, typeof(IFormatterResolver) })); + }, argBytes, argOffset); + } + else if (IsOptimizeTargetType(t)) + { + EmitOffsetPlusEqual(il, null, () => + { + argValue.EmitLoad(); + member.EmitLoadValue(il); + if (t == typeof(byte[])) + { + il.EmitCall(MessagePackBinaryTypeInfo.WriteBytes); + } + else + { + il.EmitCall(MessagePackBinaryTypeInfo.TypeInfo.GetDeclaredMethods("Write" + t.Name).OrderByDescending(x => x.GetParameters().Length).First()); + } + }, argBytes, argOffset); + } + else + { + EmitOffsetPlusEqual(il, () => + { + argResolver.EmitLoad(); + il.Emit(OpCodes.Call, getFormatterWithVerify.MakeGenericMethod(t)); + }, () => + { + argValue.EmitLoad(); + member.EmitLoadValue(il); + argResolver.EmitLoad(); + il.EmitCall(getSerialize(t)); + }, argBytes, argOffset); + } + } + + // T Deserialize([arg:1]byte[] bytes, [arg:2]int offset, [arg:3]IFormatterResolver formatterResolver, [arg:4]out int readSize); + static void BuildDeserialize(Type type, ObjectSerializationInfo info, ILGenerator il, Func tryEmitLoadCustomFormatter, int firstArgIndex) + { + var argBytes = new ArgumentField(il, firstArgIndex); + var argOffset = new ArgumentField(il, firstArgIndex + 1); + var argResolver = new ArgumentField(il, firstArgIndex + 2); + var argReadSize = new ArgumentField(il, firstArgIndex + 3); + + // if(MessagePackBinary.IsNil) readSize = 1, return null; + var falseLabel = il.DefineLabel(); + argBytes.EmitLoad(); + argOffset.EmitLoad(); + il.EmitCall(MessagePackBinaryTypeInfo.IsNil); + il.Emit(OpCodes.Brfalse_S, falseLabel); + if (type.GetTypeInfo().IsClass) + { + argReadSize.EmitLoad(); + il.EmitLdc_I4(1); + il.Emit(OpCodes.Stind_I4); + il.Emit(OpCodes.Ldnull); + il.Emit(OpCodes.Ret); + } + else + { + il.Emit(OpCodes.Ldstr, "typecode is null, struct not supported"); + il.Emit(OpCodes.Newobj, invalidOperationExceptionConstructor); + il.Emit(OpCodes.Throw); + } + + il.MarkLabel(falseLabel); + + // var startOffset = offset; + var startOffsetLocal = il.DeclareLocal(typeof(int)); // [loc:0] + argOffset.EmitLoad(); + il.EmitStloc(startOffsetLocal); + + // var length = ReadMapHeader + var length = il.DeclareLocal(typeof(int)); // [loc:1] + argBytes.EmitLoad(); + argOffset.EmitLoad(); + argReadSize.EmitLoad(); + + if (info.IsIntKey) + { + il.EmitCall(MessagePackBinaryTypeInfo.ReadArrayHeader); + } + else + { + il.EmitCall(MessagePackBinaryTypeInfo.ReadMapHeader); + } + il.EmitStloc(length); + EmitOffsetPlusReadSize(il, argOffset, argReadSize); + + // make local fields + Label? gotoDefault = null; + DeserializeInfo[] infoList; + if (info.IsIntKey) + { + var maxKey = info.Members.Select(x => x.IntKey).DefaultIfEmpty(-1).Max(); + var len = maxKey + 1; + var intKeyMap = info.Members.ToDictionary(x => x.IntKey); + + infoList = Enumerable.Range(0, len) + .Select(x => + { + ObjectSerializationInfo.EmittableMember member; + if (intKeyMap.TryGetValue(x, out member)) + { + return new DeserializeInfo + { + MemberInfo = member, + LocalField = il.DeclareLocal(member.Type), + SwitchLabel = il.DefineLabel() + }; + } + else + { + // return null MemberInfo, should filter null + if (gotoDefault == null) + { + gotoDefault = il.DefineLabel(); + } + return new DeserializeInfo + { + MemberInfo = null, + LocalField = null, + SwitchLabel = gotoDefault.Value, + }; + } + }) + .ToArray(); + } + else + { + infoList = info.Members + .Select(item => new DeserializeInfo + { + MemberInfo = item, + LocalField = il.DeclareLocal(item.Type), + // SwitchLabel = il.DefineLabel() + }) + .ToArray(); + } + + // using (MessagePackSecurity.DepthStep()) { + var depthStepLocal = il.DeclareLocal(typeof(MessagePackSecurity.ObjectGraphDepthStep)); + il.EmitCall(securityDepthStep); + il.EmitStloc(depthStepLocal); + il.BeginExceptionBlock(); + + // Read Loop(for var i = 0; i< length; i++) + if (info.IsStringKey) + { + var automata = new AutomataDictionary(); + for (int i = 0; i < info.Members.Length; i++) + { + automata.Add(info.Members[i].StringKey, i); + } + + var buffer = il.DeclareLocal(typeof(byte).MakeByRefType(), true); + var keyArraySegment = il.DeclareLocal(typeof(ArraySegment)); + var longKey = il.DeclareLocal(typeof(ulong)); + var p = il.DeclareLocal(typeof(byte*)); + var rest = il.DeclareLocal(typeof(int)); + + // fixed (byte* buffer = &bytes[0]) { + argBytes.EmitLoad(); + il.EmitLdc_I4(0); + il.Emit(OpCodes.Ldelema, typeof(byte)); + il.EmitStloc(buffer); + + // for (int i = 0; i < len; i++) + il.EmitIncrementFor(length, forILocal => + { + var readNext = il.DefineLabel(); + var loopEnd = il.DefineLabel(); + + argBytes.EmitLoad(); + argOffset.EmitLoad(); + argReadSize.EmitLoad(); + il.EmitCall(MessagePackBinaryTypeInfo.ReadStringSegment); + il.EmitStloc(keyArraySegment); + EmitOffsetPlusReadSize(il, argOffset, argReadSize); + + // p = buffer + arraySegment.Offset + il.EmitLdloc(buffer); + il.Emit(OpCodes.Conv_I); + il.EmitLdloca(keyArraySegment); + il.EmitCall(typeof(ArraySegment).GetRuntimeProperty("Offset").GetGetMethod()); + il.Emit(OpCodes.Add); + il.EmitStloc(p); + + // rest = arraySegment.Count + il.EmitLdloca(keyArraySegment); + il.EmitCall(typeof(ArraySegment).GetRuntimeProperty("Count").GetGetMethod()); + il.EmitStloc(rest); + + // if(rest == 0) goto End + il.EmitLdloc(rest); + il.Emit(OpCodes.Brfalse, readNext); + + // gen automata name lookup + automata.EmitMatch(il, p, rest, longKey, x => + { + var i = x.Value; + if (infoList[i].MemberInfo != null) + { + EmitDeserializeValue(il, infoList[i], i, tryEmitLoadCustomFormatter, argBytes, argOffset, argResolver, argReadSize); + il.Emit(OpCodes.Br, loopEnd); + } + else + { + il.Emit(OpCodes.Br, readNext); + } + }, () => + { + il.Emit(OpCodes.Br, readNext); + }); + + il.MarkLabel(readNext); + argReadSize.EmitLoad(); + argBytes.EmitLoad(); + argOffset.EmitLoad(); + il.EmitCall(MessagePackBinaryTypeInfo.ReadNextBlock); + il.Emit(OpCodes.Stind_I4); + + il.MarkLabel(loopEnd); + EmitOffsetPlusReadSize(il, argOffset, argReadSize); + }); + + // end fixed + il.Emit(OpCodes.Ldc_I4_0); + il.Emit(OpCodes.Conv_U); + il.EmitStloc(buffer); + } + else + { + var key = il.DeclareLocal(typeof(int)); + var switchDefault = il.DefineLabel(); + + il.EmitIncrementFor(length, forILocal => + { + var loopEnd = il.DefineLabel(); + + il.EmitLdloc(forILocal); + il.EmitStloc(key); + + // switch... local = Deserialize + il.EmitLdloc(key); + + il.Emit(OpCodes.Switch, infoList.Select(x => x.SwitchLabel).ToArray()); + + il.MarkLabel(switchDefault); + // default, only read. readSize = MessagePackBinary.ReadNextBlock(bytes, offset); + argReadSize.EmitLoad(); + argBytes.EmitLoad(); + argOffset.EmitLoad(); + il.EmitCall(MessagePackBinaryTypeInfo.ReadNextBlock); + il.Emit(OpCodes.Stind_I4); + il.Emit(OpCodes.Br, loopEnd); + + if (gotoDefault != null) + { + il.MarkLabel(gotoDefault.Value); + il.Emit(OpCodes.Br, switchDefault); + } + + var i = 0; + foreach (var item in infoList) + { + if (item.MemberInfo != null) + { + il.MarkLabel(item.SwitchLabel); + EmitDeserializeValue(il, item, i++, tryEmitLoadCustomFormatter, argBytes, argOffset, argResolver, argReadSize); + il.Emit(OpCodes.Br, loopEnd); + } + } + + // offset += readSize + il.MarkLabel(loopEnd); + EmitOffsetPlusReadSize(il, argOffset, argReadSize); + }); + } + + // finish readSize: readSize = offset - startOffset; + argReadSize.EmitLoad(); + argOffset.EmitLoad(); + il.EmitLdloc(startOffsetLocal); + il.Emit(OpCodes.Sub); + il.Emit(OpCodes.Stind_I4); + + // } // using (MessagePackSecurity.DepthStep()) + il.BeginFinallyBlock(); + il.EmitLdloca(depthStepLocal); + il.Emit(OpCodes.Constrained, typeof(MessagePackSecurity.ObjectGraphDepthStep)); + il.Emit(OpCodes.Callvirt, idisposableDispose); + il.EndExceptionBlock(); + + // create result object + var structLocal = EmitNewObject(il, type, info, infoList); + + // IMessagePackSerializationCallbackReceiver.OnAfterDeserialize() + if (type.GetTypeInfo().ImplementedInterfaces.Any(x => x == typeof(IMessagePackSerializationCallbackReceiver))) + { + // call directly + var runtimeMethods = type.GetRuntimeMethods().Where(x => x.Name == "OnAfterDeserialize").ToArray(); + if (runtimeMethods.Length == 1) + { + if (info.IsClass) + { + il.Emit(OpCodes.Dup); + } + else + { + il.EmitLdloca(structLocal); + } + + il.Emit(OpCodes.Call, runtimeMethods[0]); // don't use EmitCall helper(must use 'Call') + } + else + { + if (info.IsStruct) + { + il.EmitLdloc(structLocal); + il.Emit(OpCodes.Box, type); + } + else + { + il.Emit(OpCodes.Dup); + } + il.EmitCall(onAfterDeserialize); + } + } + + if (info.IsStruct) + { + il.Emit(OpCodes.Ldloc, structLocal); + } + + + il.Emit(OpCodes.Ret); + } + + static void EmitOffsetPlusReadSize(ILGenerator il, ArgumentField argOffset, ArgumentField argReadSize) + { + argOffset.EmitLoad(); + argReadSize.EmitLoad(); + il.Emit(OpCodes.Ldind_I4); + il.Emit(OpCodes.Add); + argOffset.EmitStore(); + } + + static void EmitDeserializeValue(ILGenerator il, DeserializeInfo info, int index, Func tryEmitLoadCustomFormatter, ArgumentField argBytes, ArgumentField argOffset, ArgumentField argResolver, ArgumentField argReadSize) + { + var member = info.MemberInfo; + var t = member.Type; + var emitter = tryEmitLoadCustomFormatter(index, member); + if (emitter != null) + { + emitter(); + argBytes.EmitLoad(); + argOffset.EmitLoad(); + argResolver.EmitLoad(); + argReadSize.EmitLoad(); + il.EmitCall(typeof(IMessagePackFormatter<>).MakeGenericType(t).GetRuntimeMethod("Deserialize", new[] { typeof(byte[]), typeof(int), typeof(IFormatterResolver), refInt })); + } + else if (IsOptimizeTargetType(t)) + { + il.EmitLdarg(1); + il.EmitLdarg(2); + il.EmitLdarg(4); + if (t == typeof(byte[])) + { + il.EmitCall(MessagePackBinaryTypeInfo.ReadBytes); + } + else + { + il.EmitCall(MessagePackBinaryTypeInfo.TypeInfo.GetDeclaredMethods("Read" + t.Name).OrderByDescending(x => x.GetParameters().Length).First()); + } + } + else + { + argResolver.EmitLoad(); + il.EmitCall(getFormatterWithVerify.MakeGenericMethod(t)); + argBytes.EmitLoad(); + argOffset.EmitLoad(); + argResolver.EmitLoad(); + argReadSize.EmitLoad(); + il.EmitCall(getDeserialize(t)); + } + + il.EmitStloc(info.LocalField); + } + + static LocalBuilder EmitNewObject(ILGenerator il, Type type, ObjectSerializationInfo info, DeserializeInfo[] members) + { + if (info.IsClass) + { + foreach (var item in info.ConstructorParameters) + { + var local = members.First(x => x.MemberInfo == item); + il.EmitLdloc(local.LocalField); + } + il.Emit(OpCodes.Newobj, info.BestmatchConstructor); + + foreach (var item in members.Where(x => x.MemberInfo != null && x.MemberInfo.IsWritable)) + { + il.Emit(OpCodes.Dup); + il.EmitLdloc(item.LocalField); + item.MemberInfo.EmitStoreValue(il); + } + + return null; + } + else + { + var result = il.DeclareLocal(type); + if (info.BestmatchConstructor == null) + { + il.Emit(OpCodes.Ldloca, result); + il.Emit(OpCodes.Initobj, type); + } + else + { + foreach (var item in info.ConstructorParameters) + { + var local = members.First(x => x.MemberInfo == item); + il.EmitLdloc(local.LocalField); + } + il.Emit(OpCodes.Newobj, info.BestmatchConstructor); + il.Emit(OpCodes.Stloc, result); + } + + foreach (var item in members.Where(x => x.MemberInfo != null && x.MemberInfo.IsWritable)) + { + il.EmitLdloca(result); + il.EmitLdloc(item.LocalField); + item.MemberInfo.EmitStoreValue(il); + } + + return result; // struct returns local result field + } + } + + static bool IsOptimizeTargetType(Type type) + { + if (type == typeof(Int16) + || type == typeof(Int32) + || type == typeof(Int64) + || type == typeof(UInt16) + || type == typeof(UInt32) + || type == typeof(UInt64) + || type == typeof(Single) + || type == typeof(Double) + || type == typeof(bool) + || type == typeof(byte) + || type == typeof(sbyte) + || type == typeof(char) + // not includes DateTime and String and Binary. + //|| type == typeof(DateTime) + //|| type == typeof(string) + //|| type == typeof(byte[]) + ) + { + return true; + } + return false; + } + + // EmitInfos... + + static readonly Type refByte = typeof(byte[]).MakeByRefType(); + static readonly Type refInt = typeof(int).MakeByRefType(); + static readonly MethodInfo getFormatterWithVerify = typeof(FormatterResolverExtensions).GetRuntimeMethods().First(x => x.Name == "GetFormatterWithVerify"); + private static readonly MethodInfo securityDepthStep = typeof(MessagePackSecurity).GetRuntimeMethod(nameof(MessagePackSecurity.DepthStep), Type.EmptyTypes); + private static readonly MethodInfo idisposableDispose = typeof(IDisposable).GetRuntimeMethod(nameof(IDisposable.Dispose), Type.EmptyTypes); + static readonly Func getSerialize = t => typeof(IMessagePackFormatter<>).MakeGenericType(t).GetRuntimeMethod("Serialize", new[] { refByte, typeof(int), t, typeof(IFormatterResolver) }); + static readonly Func getDeserialize = t => typeof(IMessagePackFormatter<>).MakeGenericType(t).GetRuntimeMethod("Deserialize", new[] { typeof(byte[]), typeof(int), typeof(IFormatterResolver), refInt }); + // static readonly ConstructorInfo dictionaryConstructor = typeof(ByteArrayStringHashTable).GetTypeInfo().DeclaredConstructors.First(x => { var p = x.GetParameters(); return p.Length == 1 && p[0].ParameterType == typeof(int); }); + // static readonly MethodInfo dictionaryAdd = typeof(ByteArrayStringHashTable).GetRuntimeMethod("Add", new[] { typeof(string), typeof(int) }); + // static readonly MethodInfo dictionaryTryGetValue = typeof(ByteArrayStringHashTable).GetRuntimeMethod("TryGetValue", new[] { typeof(ArraySegment), refInt }); + static readonly ConstructorInfo invalidOperationExceptionConstructor = typeof(System.InvalidOperationException).GetTypeInfo().DeclaredConstructors.First(x => { var p = x.GetParameters(); return p.Length == 1 && p[0].ParameterType == typeof(string); }); + + static readonly MethodInfo onBeforeSerialize = typeof(IMessagePackSerializationCallbackReceiver).GetRuntimeMethod("OnBeforeSerialize", Type.EmptyTypes); + static readonly MethodInfo onAfterDeserialize = typeof(IMessagePackSerializationCallbackReceiver).GetRuntimeMethod("OnAfterDeserialize", Type.EmptyTypes); + + static readonly ConstructorInfo objectCtor = typeof(object).GetTypeInfo().DeclaredConstructors.First(x => x.GetParameters().Length == 0); + + internal static class MessagePackBinaryTypeInfo + { + public static TypeInfo TypeInfo = typeof(MessagePackBinary).GetTypeInfo(); + + public static readonly MethodInfo GetEncodedStringBytes = typeof(MessagePackBinary).GetRuntimeMethod("GetEncodedStringBytes", new[] { typeof(string) }); + public static MethodInfo WriteFixedMapHeaderUnsafe = typeof(MessagePackBinary).GetRuntimeMethod("WriteFixedMapHeaderUnsafe", new[] { refByte, +typeof(int), typeof(int) }); + public static MethodInfo WriteFixedArrayHeaderUnsafe = typeof(MessagePackBinary).GetRuntimeMethod("WriteFixedArrayHeaderUnsafe", new[] { refByte, typeof(int), typeof(int) }); + public static MethodInfo WriteMapHeader = typeof(MessagePackBinary).GetRuntimeMethod("WriteMapHeader", new[] { refByte, typeof(int), typeof(int) }); + public static MethodInfo WriteArrayHeader = typeof(MessagePackBinary).GetRuntimeMethod("WriteArrayHeader", new[] { refByte, typeof(int), typeof(int) }); + public static MethodInfo WritePositiveFixedIntUnsafe = typeof(MessagePackBinary).GetRuntimeMethod("WritePositiveFixedIntUnsafe", new[] { refByte, typeof(int), typeof(int) }); + public static MethodInfo WriteInt32 = typeof(MessagePackBinary).GetRuntimeMethod("WriteInt32", new[] { refByte, typeof(int), typeof(int) }); + public static MethodInfo WriteBytes = typeof(MessagePackBinary).GetRuntimeMethod("WriteBytes", new[] { refByte, typeof(int), typeof(byte[]) }); + public static MethodInfo WriteNil = typeof(MessagePackBinary).GetRuntimeMethod("WriteNil", new[] { refByte, typeof(int) }); + public static MethodInfo ReadBytes = typeof(MessagePackBinary).GetRuntimeMethod("ReadBytes", new[] { typeof(byte[]), typeof(int), refInt }); + public static MethodInfo ReadInt32 = typeof(MessagePackBinary).GetRuntimeMethod("ReadInt32", new[] { typeof(byte[]), typeof(int), refInt }); + public static MethodInfo ReadString = typeof(MessagePackBinary).GetRuntimeMethod("ReadString", new[] { typeof(byte[]), typeof(int), refInt }); + public static MethodInfo ReadStringSegment = typeof(MessagePackBinary).GetRuntimeMethod("ReadStringSegment", new[] { typeof(byte[]), typeof(int), refInt }); + public static MethodInfo IsNil = typeof(MessagePackBinary).GetRuntimeMethod("IsNil", new[] { typeof(byte[]), typeof(int) }); + public static MethodInfo ReadNextBlock = typeof(MessagePackBinary).GetRuntimeMethod("ReadNextBlock", new[] { typeof(byte[]), typeof(int) }); + public static MethodInfo WriteStringUnsafe = typeof(MessagePackBinary).GetRuntimeMethod("WriteStringUnsafe", new[] { refByte, typeof(int), typeof(string), typeof(int) }); + public static MethodInfo WriteStringBytes = typeof(MessagePackBinary).GetRuntimeMethod("WriteStringBytes", new[] { refByte, typeof(int), typeof(byte[]) }); + public static MethodInfo WriteRaw = typeof(MessagePackBinary).GetRuntimeMethod("WriteRaw", new[] { refByte, typeof(int), typeof(byte[]) }); + + public static MethodInfo ReadArrayHeader = typeof(MessagePackBinary).GetRuntimeMethod("ReadArrayHeader", new[] { typeof(byte[]), typeof(int), refInt }); + public static MethodInfo ReadMapHeader = typeof(MessagePackBinary).GetRuntimeMethod("ReadMapHeader", new[] { typeof(byte[]), typeof(int), refInt }); + + static MessagePackBinaryTypeInfo() + { + } + } + + internal static class EmitInfo + { + public static readonly MethodInfo GetTypeFromHandle = ExpressionUtility.GetMethodInfo(() => Type.GetTypeFromHandle(default(RuntimeTypeHandle))); + public static readonly MethodInfo TypeGetProperty = ExpressionUtility.GetMethodInfo((Type t) => t.GetTypeInfo().GetProperty(default(string), default(BindingFlags))); + public static readonly MethodInfo TypeGetField = ExpressionUtility.GetMethodInfo((Type t) => t.GetTypeInfo().GetField(default(string), default(BindingFlags))); + public static readonly MethodInfo GetCustomAttributeMessagePackFormatterAttribute = ExpressionUtility.GetMethodInfo(() => CustomAttributeExtensions.GetCustomAttribute(default(MemberInfo), default(bool))); + public static readonly MethodInfo ActivatorCreateInstance = ExpressionUtility.GetMethodInfo(() => Activator.CreateInstance(default(Type), default(object[]))); + + internal static class MessagePackFormatterAttr + { + internal static readonly MethodInfo FormatterType = ExpressionUtility.GetPropertyInfo((MessagePackFormatterAttribute attr) => attr.FormatterType).GetGetMethod(); + internal static readonly MethodInfo Arguments = ExpressionUtility.GetPropertyInfo((MessagePackFormatterAttribute attr) => attr.Arguments).GetGetMethod(); + } + } + + class DeserializeInfo + { + public ObjectSerializationInfo.EmittableMember MemberInfo { get; set; } + public LocalBuilder LocalField { get; set; } + public Label SwitchLabel { get; set; } + } + } + + internal delegate int AnonymousSerializeFunc(byte[][] stringByteKeysField, object[] customFormatters, ref byte[] bytes, int offset, T value, IFormatterResolver resolver); + internal delegate T AnonymousDeserializeFunc(object[] customFormatters, byte[] bytes, int offset, IFormatterResolver resolver, out int readSize); + + internal class AnonymousSerializableFormatter : IMessagePackFormatter + { + readonly byte[][] stringByteKeysField; + readonly object[] serializeCustomFormatters; + readonly object[] deserializeCustomFormatters; + readonly AnonymousSerializeFunc serialize; + readonly AnonymousDeserializeFunc deserialize; + + public AnonymousSerializableFormatter(byte[][] stringByteKeysField, object[] serializeCustomFormatters, object[] deserializeCustomFormatters, AnonymousSerializeFunc serialize, AnonymousDeserializeFunc deserialize) + { + this.stringByteKeysField = stringByteKeysField; + this.serializeCustomFormatters = serializeCustomFormatters; + this.deserializeCustomFormatters = deserializeCustomFormatters; + this.serialize = serialize; + this.deserialize = deserialize; + } + + public int Serialize(ref byte[] bytes, int offset, T value, IFormatterResolver formatterResolver) + { + if (serialize == null) throw new InvalidOperationException(this.GetType().Name + " does not support Serialize."); + return serialize(stringByteKeysField, serializeCustomFormatters, ref bytes, offset, value, formatterResolver); + } + + public T Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize) + { + if (deserialize == null) throw new InvalidOperationException(this.GetType().Name + " does not support Deserialize."); + return deserialize(deserializeCustomFormatters, bytes, offset, formatterResolver, out readSize); + } + } + + internal class ObjectSerializationInfo + { + public Type Type { get; set; } + public bool IsIntKey { get; set; } + public bool IsStringKey { get { return !IsIntKey; } } + public bool IsClass { get; set; } + public bool IsStruct { get { return !IsClass; } } + public ConstructorInfo BestmatchConstructor { get; set; } + public EmittableMember[] ConstructorParameters { get; set; } + public EmittableMember[] Members { get; set; } + + ObjectSerializationInfo() + { + + } + + public static ObjectSerializationInfo CreateOrNull(Type type, bool forceStringKey, bool contractless, bool allowPrivate) + { + var ti = type.GetTypeInfo(); + var isClass = ti.IsClass || ti.IsInterface || ti.IsAbstract; + + var contractAttr = ti.GetCustomAttributes().FirstOrDefault(); + var dataContractAttr = ti.GetCustomAttribute(); + if (contractAttr == null && dataContractAttr == null && !forceStringKey && !contractless) + { + return null; + } + + var isIntKey = true; + var intMembers = new Dictionary(); + var stringMembers = new Dictionary(); + + if (forceStringKey || contractless || (contractAttr != null && contractAttr.KeyAsPropertyName)) + { + // All public members are serialize target except [Ignore] member. + isIntKey = !(forceStringKey || (contractAttr != null && contractAttr.KeyAsPropertyName)); + + var hiddenIntKey = 0; + foreach (var item in type.GetRuntimeProperties()) + { + if (item.GetCustomAttribute(true) != null) continue; + if (item.GetCustomAttribute(true) != null) continue; + if (item.IsIndexer()) continue; + + var getMethod = item.GetGetMethod(true); + var setMethod = item.GetSetMethod(true); + + var member = new EmittableMember + { + PropertyInfo = item, + IsReadable = (getMethod != null) && (allowPrivate || getMethod.IsPublic) && !getMethod.IsStatic, + IsWritable = (setMethod != null) && (allowPrivate || setMethod.IsPublic) && !setMethod.IsStatic, + StringKey = item.Name + }; + if (!member.IsReadable && !member.IsWritable) continue; + member.IntKey = hiddenIntKey++; + if (isIntKey) + { + intMembers.Add(member.IntKey, member); + } + else + { + stringMembers.Add(member.StringKey, member); + } + } + foreach (var item in type.GetRuntimeFields()) + { + if (item.GetCustomAttribute(true) != null) continue; + if (item.GetCustomAttribute(true) != null) continue; + if (item.GetCustomAttribute(true) != null) continue; + if (item.IsStatic) continue; + + var member = new EmittableMember + { + FieldInfo = item, + IsReadable = allowPrivate || item.IsPublic, + IsWritable = allowPrivate || (item.IsPublic && !item.IsInitOnly), + StringKey = item.Name + }; + if (!member.IsReadable && !member.IsWritable) continue; + member.IntKey = hiddenIntKey++; + if (isIntKey) + { + intMembers.Add(member.IntKey, member); + } + else + { + stringMembers.Add(member.StringKey, member); + } + } + } + else + { + // Public members with KeyAttribute except [Ignore] member. + var searchFirst = true; + var hiddenIntKey = 0; + + foreach (var item in type.GetRuntimeProperties()) + { + if (item.GetCustomAttribute(true) != null) continue; + if (item.GetCustomAttribute(true) != null) continue; + if (item.IsIndexer()) continue; + + var getMethod = item.GetGetMethod(true); + var setMethod = item.GetSetMethod(true); + + var member = new EmittableMember + { + PropertyInfo = item, + IsReadable = (getMethod != null) && (allowPrivate || getMethod.IsPublic) && !getMethod.IsStatic, + IsWritable = (setMethod != null) && (allowPrivate || setMethod.IsPublic) && !setMethod.IsStatic, + }; + if (!member.IsReadable && !member.IsWritable) continue; + + KeyAttribute key; + if (contractAttr != null) + { + // MessagePackObjectAttribute + key = item.GetCustomAttribute(true); + if (key == null) + { + throw new MessagePackDynamicObjectResolverException("all public members must mark KeyAttribute or IgnoreMemberAttribute." + " type: " + type.FullName + " member:" + item.Name); + } + + if (key.IntKey == null && key.StringKey == null) throw new MessagePackDynamicObjectResolverException("both IntKey and StringKey are null." + " type: " + type.FullName + " member:" + item.Name); + } + else + { + // DataContractAttribute + var pseudokey = item.GetCustomAttribute(true); + if (pseudokey == null) + { + // This member has no DataMemberAttribute nor IgnoreMemberAttribute. + // But the type *did* have a DataContractAttribute on it, so no attribute implies the member should not be serialized. + continue; + } + + // use Order first + if (pseudokey.Order != -1) + { + key = new KeyAttribute(pseudokey.Order); + } + else if (pseudokey.Name != null) + { + key = new KeyAttribute(pseudokey.Name); + } + else + { + key = new KeyAttribute(item.Name); // use property name + } + } + + if (searchFirst) + { + searchFirst = false; + isIntKey = key.IntKey != null; + } + else + { + if ((isIntKey && key.IntKey == null) || (!isIntKey && key.StringKey == null)) + { + throw new MessagePackDynamicObjectResolverException("all members key type must be same." + " type: " + type.FullName + " member:" + item.Name); + } + } + + if (isIntKey) + { + member.IntKey = key.IntKey.Value; + if (intMembers.ContainsKey(member.IntKey)) throw new MessagePackDynamicObjectResolverException("key is duplicated, all members key must be unique." + " type: " + type.FullName + " member:" + item.Name); + + intMembers.Add(member.IntKey, member); + } + else + { + member.StringKey = key.StringKey; + if (stringMembers.ContainsKey(member.StringKey)) throw new MessagePackDynamicObjectResolverException("key is duplicated, all members key must be unique." + " type: " + type.FullName + " member:" + item.Name); + + member.IntKey = hiddenIntKey++; + stringMembers.Add(member.StringKey, member); + } + } + + foreach (var item in type.GetRuntimeFields()) + { + if (item.GetCustomAttribute(true) != null) continue; + if (item.GetCustomAttribute(true) != null) continue; + if (item.GetCustomAttribute(true) != null) continue; + if (item.IsStatic) continue; + + var member = new EmittableMember + { + FieldInfo = item, + IsReadable = allowPrivate || item.IsPublic, + IsWritable = allowPrivate || (item.IsPublic && !item.IsInitOnly), + }; + if (!member.IsReadable && !member.IsWritable) continue; + + KeyAttribute key; + if (contractAttr != null) + { + // MessagePackObjectAttribute + key = item.GetCustomAttribute(true); + if (key == null) + { + throw new MessagePackDynamicObjectResolverException("all public members must mark KeyAttribute or IgnoreMemberAttribute." + " type: " + type.FullName + " member:" + item.Name); + } + + if (key.IntKey == null && key.StringKey == null) throw new MessagePackDynamicObjectResolverException("both IntKey and StringKey are null." + " type: " + type.FullName + " member:" + item.Name); + } + else + { + // DataContractAttribute + var pseudokey = item.GetCustomAttribute(true); + if (pseudokey == null) + { + // This member has no DataMemberAttribute nor IgnoreMemberAttribute. + // But the type *did* have a DataContractAttribute on it, so no attribute implies the member should not be serialized. + continue; + } + + // use Order first + if (pseudokey.Order != -1) + { + key = new KeyAttribute(pseudokey.Order); + } + else if (pseudokey.Name != null) + { + key = new KeyAttribute(pseudokey.Name); + } + else + { + key = new KeyAttribute(item.Name); // use property name + } + } + + if (searchFirst) + { + searchFirst = false; + isIntKey = key.IntKey != null; + } + else + { + if ((isIntKey && key.IntKey == null) || (!isIntKey && key.StringKey == null)) + { + throw new MessagePackDynamicObjectResolverException("all members key type must be same." + " type: " + type.FullName + " member:" + item.Name); + } + } + + if (isIntKey) + { + member.IntKey = key.IntKey.Value; + if (intMembers.ContainsKey(member.IntKey)) throw new MessagePackDynamicObjectResolverException("key is duplicated, all members key must be unique." + " type: " + type.FullName + " member:" + item.Name); + + intMembers.Add(member.IntKey, member); + } + else + { + member.StringKey = key.StringKey; + if (stringMembers.ContainsKey(member.StringKey)) throw new MessagePackDynamicObjectResolverException("key is duplicated, all members key must be unique." + " type: " + type.FullName + " member:" + item.Name); + + member.IntKey = hiddenIntKey++; + stringMembers.Add(member.StringKey, member); + } + } + } + + // GetConstructor + IEnumerator ctorEnumerator = null; + var ctor = ti.DeclaredConstructors.Where(x => x.IsPublic).SingleOrDefault(x => x.GetCustomAttribute(false) != null); + if (ctor == null) + { + ctorEnumerator = + ti.DeclaredConstructors.Where(x => x.IsPublic).OrderBy(x => x.GetParameters().Length) + .GetEnumerator(); + + if (ctorEnumerator.MoveNext()) + { + ctor = ctorEnumerator.Current; + } + } + // struct allows null ctor + if (ctor == null && isClass) throw new MessagePackDynamicObjectResolverException("can't find public constructor. type:" + type.FullName); + + var constructorParameters = new List(); + if (ctor != null) + { + var constructorLookupDictionary = stringMembers.ToLookup(x => x.Key, x => x, StringComparer.OrdinalIgnoreCase); + do + { + constructorParameters.Clear(); + var ctorParamIndex = 0; + foreach (var item in ctor.GetParameters()) + { + EmittableMember paramMember; + if (isIntKey) + { + if (intMembers.TryGetValue(ctorParamIndex, out paramMember)) + { + if ((item.ParameterType == paramMember.Type || + item.ParameterType.GetTypeInfo().IsAssignableFrom(paramMember.Type)) + && paramMember.IsReadable) + { + constructorParameters.Add(paramMember); + } + else + { + if (ctorEnumerator != null) + { + ctor = null; + continue; + } + else + { + throw new MessagePackDynamicObjectResolverException("can't find matched constructor parameter, parameterType mismatch. type:" + type.FullName + " parameterIndex:" + ctorParamIndex + " paramterType:" + item.ParameterType.Name); + } + } + } + else + { + if (ctorEnumerator != null) + { + ctor = null; + continue; + } + else + { + throw new MessagePackDynamicObjectResolverException("can't find matched constructor parameter, index not found. type:" + type.FullName + " parameterIndex:" + ctorParamIndex); + } + } + } + else + { + var hasKey = constructorLookupDictionary[item.Name]; + var len = hasKey.Count(); + if (len != 0) + { + if (len != 1) + { + if (ctorEnumerator != null) + { + ctor = null; + continue; + } + else + { + throw new MessagePackDynamicObjectResolverException("duplicate matched constructor parameter name:" + type.FullName + " parameterName:" + item.Name + " paramterType:" + item.ParameterType.Name); + } + } + + paramMember = hasKey.First().Value; + if (item.ParameterType == paramMember.Type && paramMember.IsReadable) + { + constructorParameters.Add(paramMember); + } + else + { + if (ctorEnumerator != null) + { + ctor = null; + continue; + } + else + { + throw new MessagePackDynamicObjectResolverException("can't find matched constructor parameter, parameterType mismatch. type:" + type.FullName + " parameterName:" + item.Name + " paramterType:" + item.ParameterType.Name); + } + } + } + else + { + if (ctorEnumerator != null) + { + ctor = null; + continue; + } + else + { + throw new MessagePackDynamicObjectResolverException("can't find matched constructor parameter, index not found. type:" + type.FullName + " parameterName:" + item.Name); + } + } + } + ctorParamIndex++; + } + } while (TryGetNextConstructor(ctorEnumerator, ref ctor)); + + if (ctor == null) + { + throw new MessagePackDynamicObjectResolverException("can't find matched constructor. type:" + type.FullName); + } + } + + EmittableMember[] members; + if (isIntKey) + { + members = intMembers.Values.OrderBy(x => x.IntKey).ToArray(); + } + else + { + members = stringMembers.Values + .OrderBy(x => + { + var attr = x.GetDataMemberAttribute(); + if (attr == null) return int.MaxValue; + return attr.Order; + }) + .ToArray(); + } + + return new ObjectSerializationInfo + { + Type = type, + IsClass = isClass, + BestmatchConstructor = ctor, + ConstructorParameters = constructorParameters.ToArray(), + IsIntKey = isIntKey, + Members = members, + }; + } + + static bool TryGetNextConstructor(IEnumerator ctorEnumerator, ref ConstructorInfo ctor) + { + if (ctorEnumerator == null || ctor != null) + { + return false; + } + + if (ctorEnumerator.MoveNext()) + { + ctor = ctorEnumerator.Current; + return true; + } + else + { + ctor = null; + return false; + } + } + + internal class EmittableMember + { + public bool IsProperty { get { return PropertyInfo != null; } } + public bool IsField { get { return FieldInfo != null; } } + public bool IsWritable { get; set; } + public bool IsReadable { get; set; } + public int IntKey { get; set; } + public string StringKey { get; set; } + public Type Type { get { return IsField ? FieldInfo.FieldType : PropertyInfo.PropertyType; } } + public FieldInfo FieldInfo { get; set; } + public PropertyInfo PropertyInfo { get; set; } + + public string Name + { + get + { + return IsProperty ? PropertyInfo.Name : FieldInfo.Name; + } + } + + public bool IsValueType + { + get + { + var mi = IsProperty ? (MemberInfo)PropertyInfo : FieldInfo; + return mi.DeclaringType.GetTypeInfo().IsValueType; + } + } + + public MessagePackFormatterAttribute GetMessagePackFormatterAttribute() + { + if (IsProperty) + { + return (MessagePackFormatterAttribute)PropertyInfo.GetCustomAttribute(true); + } + else + { + return (MessagePackFormatterAttribute)FieldInfo.GetCustomAttribute(true); + } + } + + public DataMemberAttribute GetDataMemberAttribute() + { + if (IsProperty) + { + return (DataMemberAttribute)PropertyInfo.GetCustomAttribute(true); + } + else + { + return (DataMemberAttribute)FieldInfo.GetCustomAttribute(true); + } + } + + public void EmitLoadValue(ILGenerator il) + { + if (IsProperty) + { + il.EmitCall(PropertyInfo.GetGetMethod(true)); + } + else + { + il.Emit(OpCodes.Ldfld, FieldInfo); + } + } + + public void EmitStoreValue(ILGenerator il) + { + if (IsProperty) + { + il.EmitCall(PropertyInfo.GetSetMethod(true)); + } + else + { + il.Emit(OpCodes.Stfld, FieldInfo); + } + } + + //public object ReflectionLoadValue(object value) + //{ + // if (IsProperty) + // { + // return PropertyInfo.GetValue(value, null); + // } + // else + // { + // return FieldInfo.GetValue(value); + // } + //} + + //public void ReflectionStoreValue(object obj, object value) + //{ + // if (IsProperty) + // { + // PropertyInfo.SetValue(obj, value, null); + // } + // else + // { + // FieldInfo.SetValue(obj, value); + // } + //} + } + } + + internal class MessagePackDynamicObjectResolverException : Exception + { + public MessagePackDynamicObjectResolverException(string message) + : base(message) + { + + } + } +} + +#endif +#endif diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/DynamicUnionResolver.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/DynamicUnionResolver.cs new file mode 100644 index 000000000..aa6487c4d --- /dev/null +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/DynamicUnionResolver.cs @@ -0,0 +1,523 @@ +//------------------------------------------------------------------------------ +// +// This file was automatically generated by the UpdateVendors tool. +//------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 +using System; +using System.Linq; +using Datadog.Trace.Vendors.MessagePack.Formatters; +using Datadog.Trace.Vendors.MessagePack.Internal; +using System.Reflection; +using System.Reflection.Emit; +using System.Collections.Generic; +using System.Text.RegularExpressions; +using System.Threading; + +namespace Datadog.Trace.Vendors.MessagePack.Resolvers +{ +#if !UNITY_WSA +#if !NET_STANDARD_2_0 + + /// + /// UnionResolver by dynamic code generation. + /// + internal sealed class DynamicUnionResolver : IFormatterResolver + { + public static readonly DynamicUnionResolver Instance = new DynamicUnionResolver(); + + const string ModuleName = "MessagePack.Resolvers.DynamicUnionResolver"; + + static readonly DynamicAssembly assembly; +#if NETSTANDARD || NETFRAMEWORK + static readonly Regex SubtractFullNameRegex = new Regex(@", Version=\d+.\d+.\d+.\d+, Culture=\w+, PublicKeyToken=\w+", RegexOptions.Compiled); +#else + static readonly Regex SubtractFullNameRegex = new Regex(@", Version=\d+.\d+.\d+.\d+, Culture=\w+, PublicKeyToken=\w+"); +#endif + + static int nameSequence = 0; + + DynamicUnionResolver() + { + + } + + static DynamicUnionResolver() + { + assembly = new DynamicAssembly(ModuleName); + } + +#if NETFRAMEWORK + public AssemblyBuilder Save() + { + return assembly.Save(); + } +#endif + + public IMessagePackFormatter GetFormatter() + { + return FormatterCache.formatter; + } + + static class FormatterCache + { + public static readonly IMessagePackFormatter formatter; + + static FormatterCache() + { + var ti = typeof(T).GetTypeInfo(); + if (ti.IsNullable()) + { + ti = ti.GenericTypeArguments[0].GetTypeInfo(); + + var innerFormatter = DynamicUnionResolver.Instance.GetFormatterDynamic(ti.AsType()); + if (innerFormatter == null) + { + return; + } + formatter = (IMessagePackFormatter)Activator.CreateInstance(typeof(StaticNullableFormatter<>).MakeGenericType(ti.AsType()), new object[] { innerFormatter }); + return; + } + + var formatterTypeInfo = BuildType(typeof(T)); + if (formatterTypeInfo == null) return; + + formatter = (IMessagePackFormatter)Activator.CreateInstance(formatterTypeInfo.AsType()); + } + } + + static TypeInfo BuildType(Type type) + { + var ti = type.GetTypeInfo(); + // order by key(important for use jump-table of switch) + var unionAttrs = ti.GetCustomAttributes().OrderBy(x => x.Key).ToArray(); + + if (unionAttrs.Length == 0) return null; + if (!ti.IsInterface && !ti.IsAbstract) + { + throw new MessagePackDynamicUnionResolverException("Union can only be interface or abstract class. Type:" + type.Name); + } + + var checker1 = new HashSet(); + var checker2 = new HashSet(); + foreach (var item in unionAttrs) + { + if (!checker1.Add(item.Key)) throw new MessagePackDynamicUnionResolverException("Same union key has found. Type:" + type.Name + " Key:" + item.Key); + if (!checker2.Add(item.SubType)) throw new MessagePackDynamicUnionResolverException("Same union subType has found. Type:" + type.Name + " SubType: " + item.SubType); + } + + var formatterType = typeof(IMessagePackFormatter<>).MakeGenericType(type); + var typeBuilder = assembly.DefineType("MessagePack.Formatters." + SubtractFullNameRegex.Replace(type.FullName, "").Replace(".", "_") + "Formatter" + +Interlocked.Increment(ref nameSequence), TypeAttributes.Public | TypeAttributes.Sealed, null, new[] { formatterType }); + + FieldBuilder typeToKeyAndJumpMap = null; // Dictionary> + FieldBuilder keyToJumpMap = null; // Dictionary + + // create map dictionary + { + var method = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, Type.EmptyTypes); + typeToKeyAndJumpMap = typeBuilder.DefineField("typeToKeyAndJumpMap", typeof(Dictionary>), FieldAttributes.Private | FieldAttributes.InitOnly); + keyToJumpMap = typeBuilder.DefineField("keyToJumpMap", typeof(Dictionary), FieldAttributes.Private | FieldAttributes.InitOnly); + + var il = method.GetILGenerator(); + BuildConstructor(type, unionAttrs, method, typeToKeyAndJumpMap, keyToJumpMap, il); + } + + { + var method = typeBuilder.DefineMethod("Serialize", MethodAttributes.Public | MethodAttributes.Final | MethodAttributes.Virtual, + typeof(int), + new Type[] { typeof(byte[]).MakeByRefType(), typeof(int), type, typeof(IFormatterResolver) }); + + var il = method.GetILGenerator(); + BuildSerialize(type, unionAttrs, method, typeToKeyAndJumpMap, il); + } + { + var method = typeBuilder.DefineMethod("Deserialize", MethodAttributes.Public | MethodAttributes.Final | MethodAttributes.Virtual, + type, + new Type[] { typeof(byte[]), typeof(int), typeof(IFormatterResolver), typeof(int).MakeByRefType() }); + + var il = method.GetILGenerator(); + BuildDeserialize(type, unionAttrs, method, keyToJumpMap, il); + } + + return typeBuilder.CreateTypeInfo(); + } + + static void BuildConstructor(Type type, UnionAttribute[] infos, ConstructorInfo method, FieldBuilder typeToKeyAndJumpMap, FieldBuilder keyToJumpMap, ILGenerator il) + { + il.EmitLdarg(0); + il.Emit(OpCodes.Call, objectCtor); + + { + il.EmitLdarg(0); + il.EmitLdc_I4(infos.Length); + il.Emit(OpCodes.Ldsfld, runtimeTypeHandleEqualityComparer); + il.Emit(OpCodes.Newobj, typeMapDictionaryConstructor); + + var index = 0; + foreach (var item in infos) + { + il.Emit(OpCodes.Dup); + il.Emit(OpCodes.Ldtoken, item.SubType); + il.EmitLdc_I4(item.Key); + il.EmitLdc_I4(index); + il.Emit(OpCodes.Newobj, intIntKeyValuePairConstructor); + il.EmitCall(typeMapDictionaryAdd); + + index++; + } + + il.Emit(OpCodes.Stfld, typeToKeyAndJumpMap); + } + { + il.EmitLdarg(0); + il.EmitLdc_I4(infos.Length); + il.Emit(OpCodes.Newobj, keyMapDictionaryConstructor); + + var index = 0; + foreach (var item in infos) + { + il.Emit(OpCodes.Dup); + il.EmitLdc_I4(item.Key); + il.EmitLdc_I4(index); + il.EmitCall(keyMapDictionaryAdd); + + index++; + } + il.Emit(OpCodes.Stfld, keyToJumpMap); + } + + il.Emit(OpCodes.Ret); + } + + + // int Serialize([arg:1]ref byte[] bytes, [arg:2]int offset, [arg:3]T value, [arg:4]IFormatterResolver formatterResolver); + static void BuildSerialize(Type type, UnionAttribute[] infos, MethodBuilder method, FieldBuilder typeToKeyAndJumpMap, ILGenerator il) + { + // if(value == null) return WriteNil + var elseBody = il.DefineLabel(); + var notFoundType = il.DefineLabel(); + + il.EmitLdarg(3); + il.Emit(OpCodes.Brtrue_S, elseBody); + il.Emit(OpCodes.Br, notFoundType); + il.MarkLabel(elseBody); + + var keyPair = il.DeclareLocal(typeof(KeyValuePair)); + + il.EmitLoadThis(); + il.EmitLdfld(typeToKeyAndJumpMap); + il.EmitLdarg(3); + il.EmitCall(objectGetType); + il.EmitCall(getTypeHandle); + il.EmitLdloca(keyPair); + il.EmitCall(typeMapDictionaryTryGetValue); + il.Emit(OpCodes.Brfalse, notFoundType); + + // var startOffset = offset; + var startOffsetLocal = il.DeclareLocal(typeof(int)); + il.EmitLdarg(2); + il.EmitStloc(startOffsetLocal); + + // offset += WriteFixedArrayHeaderUnsafe(,,2); + EmitOffsetPlusEqual(il, null, () => + { + il.EmitLdc_I4(2); + il.EmitCall(MessagePackBinaryTypeInfo.WriteFixedArrayHeaderUnsafe); + }); + + // offset += WriteInt32(,,keyPair.Key) + EmitOffsetPlusEqual(il, null, () => + { + il.EmitLdloca(keyPair); + il.EmitCall(intIntKeyValuePairGetKey); + il.EmitCall(MessagePackBinaryTypeInfo.WriteInt32); + }); + + var loopEnd = il.DefineLabel(); + + // switch-case (offset += resolver.GetFormatter.Serialize(with cast) + var switchLabels = infos.Select(x => new { Label = il.DefineLabel(), Attr = x }).ToArray(); + il.EmitLdloca(keyPair); + il.EmitCall(intIntKeyValuePairGetValue); + il.Emit(OpCodes.Switch, switchLabels.Select(x => x.Label).ToArray()); + il.Emit(OpCodes.Br, loopEnd); // default + + foreach (var item in switchLabels) + { + il.MarkLabel(item.Label); + EmitOffsetPlusEqual(il, () => + { + il.EmitLdarg(4); + il.Emit(OpCodes.Call, getFormatterWithVerify.MakeGenericMethod(item.Attr.SubType)); + }, () => + { + il.EmitLdarg(3); + if (item.Attr.SubType.GetTypeInfo().IsValueType) + { + il.Emit(OpCodes.Unbox_Any, item.Attr.SubType); + } + else + { + il.Emit(OpCodes.Castclass, item.Attr.SubType); + } + il.EmitLdarg(4); + il.Emit(OpCodes.Callvirt, getSerialize(item.Attr.SubType)); + }); + + il.Emit(OpCodes.Br, loopEnd); + } + + // return startOffset- offset; + il.MarkLabel(loopEnd); + il.EmitLdarg(2); + il.EmitLdloc(startOffsetLocal); + il.Emit(OpCodes.Sub); + il.Emit(OpCodes.Ret); + + // else, return WriteNil + il.MarkLabel(notFoundType); + il.EmitLdarg(1); + il.EmitLdarg(2); + il.EmitCall(MessagePackBinaryTypeInfo.WriteNil); + il.Emit(OpCodes.Ret); + } + + // offset += ***(ref bytes, offset.... + static void EmitOffsetPlusEqual(ILGenerator il, Action loadEmit, Action emit) + { + il.EmitLdarg(2); + + if (loadEmit != null) loadEmit(); + + il.EmitLdarg(1); + il.EmitLdarg(2); + + emit(); + + il.Emit(OpCodes.Add); + il.EmitStarg(2); + } + + // T Deserialize([arg:1]byte[] bytes, [arg:2]int offset, [arg:3]IFormatterResolver formatterResolver, [arg:4]out int readSize); + static void BuildDeserialize(Type type, UnionAttribute[] infos, MethodBuilder method, FieldBuilder keyToJumpMap, ILGenerator il) + { + // if(MessagePackBinary.IsNil) readSize = 1, return null; + var falseLabel = il.DefineLabel(); + il.EmitLdarg(1); + il.EmitLdarg(2); + il.EmitCall(MessagePackBinaryTypeInfo.IsNil); + il.Emit(OpCodes.Brfalse_S, falseLabel); + + il.EmitLdarg(4); + il.EmitLdc_I4(1); + il.Emit(OpCodes.Stind_I4); + il.Emit(OpCodes.Ldnull); + il.Emit(OpCodes.Ret); + + // read-array header and validate, ReadArrayHeader(bytes, offset, out readSize) != 2) throw; + il.MarkLabel(falseLabel); + var startOffset = il.DeclareLocal(typeof(int)); + il.EmitLdarg(2); + il.EmitStloc(startOffset); + + var rightLabel = il.DefineLabel(); + il.EmitLdarg(1); + il.EmitLdarg(2); + il.EmitLdarg(4); + il.EmitCall(MessagePackBinaryTypeInfo.ReadArrayHeader); + il.EmitLdc_I4(2); + il.Emit(OpCodes.Beq_S, rightLabel); + il.Emit(OpCodes.Ldstr, "Invalid Union data was detected. Type:" + type.FullName); + il.Emit(OpCodes.Newobj, invalidOperationExceptionConstructor); + il.Emit(OpCodes.Throw); + + il.MarkLabel(rightLabel); + EmitOffsetPlusReadSize(il); + + // read key + var key = il.DeclareLocal(typeof(int)); + il.EmitLdarg(1); + il.EmitLdarg(2); + il.EmitLdarg(4); + il.EmitCall(MessagePackBinaryTypeInfo.ReadInt32); + il.EmitStloc(key); + EmitOffsetPlusReadSize(il); + + // is-sequential don't need else convert key to jump-table value + if (!IsZeroStartSequential(infos)) + { + var endKeyMapGet = il.DefineLabel(); + il.EmitLdarg(0); + il.EmitLdfld(keyToJumpMap); + il.EmitLdloc(key); + il.EmitLdloca(key); + il.EmitCall(keyMapDictionaryTryGetValue); + il.Emit(OpCodes.Brtrue_S, endKeyMapGet); + il.EmitLdc_I4(-1); + il.EmitStloc(key); + + il.MarkLabel(endKeyMapGet); + } + + // switch->read + var result = il.DeclareLocal(type); + var loopEnd = il.DefineLabel(); + il.Emit(OpCodes.Ldnull); + il.EmitStloc(result); + il.Emit(OpCodes.Ldloc, key); + + var switchLabels = infos.Select(x => new { Label = il.DefineLabel(), Attr = x }).ToArray(); + il.Emit(OpCodes.Switch, switchLabels.Select(x => x.Label).ToArray()); + + // default + il.EmitLdarg(2); + il.EmitLdarg(1); + il.EmitLdarg(2); + il.EmitCall(MessagePackBinaryTypeInfo.ReadNextBlock); + il.Emit(OpCodes.Add); + il.EmitStarg(2); + il.Emit(OpCodes.Br, loopEnd); + + foreach (var item in switchLabels) + { + il.MarkLabel(item.Label); + il.EmitLdarg(3); + il.EmitCall(getFormatterWithVerify.MakeGenericMethod(item.Attr.SubType)); + il.EmitLdarg(1); + il.EmitLdarg(2); + il.EmitLdarg(3); + il.EmitLdarg(4); + il.EmitCall(getDeserialize(item.Attr.SubType)); + if (item.Attr.SubType.GetTypeInfo().IsValueType) + { + il.Emit(OpCodes.Box, item.Attr.SubType); + } + il.Emit(OpCodes.Stloc, result); + EmitOffsetPlusReadSize(il); + il.Emit(OpCodes.Br, loopEnd); + } + + il.MarkLabel(loopEnd); + + //// finish readSize = offset - startOffset; + il.EmitLdarg(4); + il.EmitLdarg(2); + il.EmitLdloc(startOffset); + il.Emit(OpCodes.Sub); + il.Emit(OpCodes.Stind_I4); + il.Emit(OpCodes.Ldloc, result); + il.Emit(OpCodes.Ret); + } + + static bool IsZeroStartSequential(UnionAttribute[] infos) + { + for (int i = 0; i < infos.Length; i++) + { + if (infos[i].Key != i) return false; + } + return true; + } + + static void EmitOffsetPlusReadSize(ILGenerator il) + { + il.EmitLdarg(2); + il.EmitLdarg(4); + il.Emit(OpCodes.Ldind_I4); + il.Emit(OpCodes.Add); + il.EmitStarg(2); + } + + // EmitInfos... + + static readonly Type refByte = typeof(byte[]).MakeByRefType(); + static readonly Type refInt = typeof(int).MakeByRefType(); + static readonly Type refKvp = typeof(KeyValuePair).MakeByRefType(); + static readonly MethodInfo getFormatterWithVerify = typeof(FormatterResolverExtensions).GetRuntimeMethods().First(x => x.Name == "GetFormatterWithVerify"); + + static readonly Func getSerialize = t => typeof(IMessagePackFormatter<>).MakeGenericType(t).GetRuntimeMethod("Serialize", new[] { refByte, typeof(int), t, typeof(IFormatterResolver) }); + static readonly Func getDeserialize = t => typeof(IMessagePackFormatter<>).MakeGenericType(t).GetRuntimeMethod("Deserialize", new[] { typeof(byte[]), typeof(int), typeof(IFormatterResolver), refInt }); + + static readonly FieldInfo runtimeTypeHandleEqualityComparer = typeof(RuntimeTypeHandleEqualityComparer).GetRuntimeField("Default"); + static readonly ConstructorInfo intIntKeyValuePairConstructor = typeof(KeyValuePair).GetTypeInfo().DeclaredConstructors.First(x => x.GetParameters().Length == 2); + static readonly ConstructorInfo typeMapDictionaryConstructor = typeof(Dictionary>).GetTypeInfo().DeclaredConstructors.First(x => { var p = x.GetParameters(); return p.Length == 2 && p[0].ParameterType == typeof(int); }); + static readonly MethodInfo typeMapDictionaryAdd = typeof(Dictionary>).GetRuntimeMethod("Add", new[] { typeof(RuntimeTypeHandle), typeof(KeyValuePair) }); + static readonly MethodInfo typeMapDictionaryTryGetValue = typeof(Dictionary>).GetRuntimeMethod("TryGetValue", new[] { typeof(RuntimeTypeHandle), refKvp }); + + static readonly ConstructorInfo keyMapDictionaryConstructor = typeof(Dictionary).GetTypeInfo().DeclaredConstructors.First(x => { var p = x.GetParameters(); return p.Length == 1 && p[0].ParameterType == typeof(int); }); + static readonly MethodInfo keyMapDictionaryAdd = typeof(Dictionary).GetRuntimeMethod("Add", new[] { typeof(int), typeof(int) }); + static readonly MethodInfo keyMapDictionaryTryGetValue = typeof(Dictionary).GetRuntimeMethod("TryGetValue", new[] { typeof(int), refInt }); + + static readonly MethodInfo objectGetType = typeof(object).GetRuntimeMethod("GetType", Type.EmptyTypes); + static readonly MethodInfo getTypeHandle = typeof(Type).GetRuntimeProperty("TypeHandle").GetGetMethod(); + + static readonly MethodInfo intIntKeyValuePairGetKey = typeof(KeyValuePair).GetRuntimeProperty("Key").GetGetMethod(); + static readonly MethodInfo intIntKeyValuePairGetValue = typeof(KeyValuePair).GetRuntimeProperty("Value").GetGetMethod(); + + static readonly ConstructorInfo invalidOperationExceptionConstructor = typeof(System.InvalidOperationException).GetTypeInfo().DeclaredConstructors.First(x => { var p = x.GetParameters(); return p.Length == 1 && p[0].ParameterType == typeof(string); }); + static readonly ConstructorInfo objectCtor = typeof(object).GetTypeInfo().DeclaredConstructors.First(x => x.GetParameters().Length == 0); + + static class MessagePackBinaryTypeInfo + { + public static TypeInfo TypeInfo = typeof(MessagePackBinary).GetTypeInfo(); + + public static MethodInfo WriteFixedMapHeaderUnsafe = typeof(MessagePackBinary).GetRuntimeMethod("WriteFixedMapHeaderUnsafe", new[] { refByte, typeof(int), typeof(int) }); + public static MethodInfo WriteFixedArrayHeaderUnsafe = typeof(MessagePackBinary).GetRuntimeMethod("WriteFixedArrayHeaderUnsafe", new[] { refByte, typeof(int), typeof(int) }); + public static MethodInfo WriteMapHeader = typeof(MessagePackBinary).GetRuntimeMethod("WriteMapHeader", new[] { refByte, typeof(int), typeof(int) }); + public static MethodInfo WriteArrayHeader = typeof(MessagePackBinary).GetRuntimeMethod("WriteArrayHeader", new[] { refByte, typeof(int), typeof(int) }); + public static MethodInfo WritePositiveFixedIntUnsafe = typeof(MessagePackBinary).GetRuntimeMethod("WritePositiveFixedIntUnsafe", new[] { refByte, typeof(int), typeof(int) }); + public static MethodInfo WriteInt32 = typeof(MessagePackBinary).GetRuntimeMethod("WriteInt32", new[] { refByte, typeof(int), typeof(int) }); + public static MethodInfo WriteBytes = typeof(MessagePackBinary).GetRuntimeMethod("WriteBytes", new[] { refByte, typeof(int), typeof(byte[]) }); + public static MethodInfo WriteNil = typeof(MessagePackBinary).GetRuntimeMethod("WriteNil", new[] { refByte, typeof(int) }); + public static MethodInfo ReadBytes = typeof(MessagePackBinary).GetRuntimeMethod("ReadBytes", new[] { typeof(byte[]), typeof(int), refInt }); + public static MethodInfo ReadInt32 = typeof(MessagePackBinary).GetRuntimeMethod("ReadInt32", new[] { typeof(byte[]), typeof(int), refInt }); + public static MethodInfo ReadString = typeof(MessagePackBinary).GetRuntimeMethod("ReadString", new[] { typeof(byte[]), typeof(int), refInt }); + public static MethodInfo IsNil = typeof(MessagePackBinary).GetRuntimeMethod("IsNil", new[] { typeof(byte[]), typeof(int) }); + public static MethodInfo ReadNextBlock = typeof(MessagePackBinary).GetRuntimeMethod("ReadNextBlock", new[] { typeof(byte[]), typeof(int) }); + public static MethodInfo WriteStringUnsafe = typeof(MessagePackBinary).GetRuntimeMethod("WriteStringUnsafe", new[] { refByte, typeof(int), typeof(string), typeof(int) }); + + public static MethodInfo ReadArrayHeader = typeof(MessagePackBinary).GetRuntimeMethod("ReadArrayHeader", new[] { typeof(byte[]), typeof(int), refInt }); + public static MethodInfo ReadMapHeader = typeof(MessagePackBinary).GetRuntimeMethod("ReadMapHeader", new[] { typeof(byte[]), typeof(int), refInt }); + + static MessagePackBinaryTypeInfo() + { + } + } + } + +#endif +#endif +} + +namespace Datadog.Trace.Vendors.MessagePack.Internal +{ + // RuntimeTypeHandle can embed directly by OpCodes.Ldtoken + // It does not implements IEquatable(but GetHashCode and Equals is implemented) so needs this to avoid boxing. + internal class RuntimeTypeHandleEqualityComparer : IEqualityComparer + { + public static IEqualityComparer Default = new RuntimeTypeHandleEqualityComparer(); + + RuntimeTypeHandleEqualityComparer() + { + + } + + public bool Equals(RuntimeTypeHandle x, RuntimeTypeHandle y) + { + return x.Equals(y); + } + + public int GetHashCode(RuntimeTypeHandle obj) + { + return obj.GetHashCode(); + } + } + + internal class MessagePackDynamicUnionResolverException : Exception + { + public MessagePackDynamicUnionResolverException(string message) + : base(message) + { + + } + } +} + diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/NativeDateTimeResolver.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/NativeDateTimeResolver.cs index 977d1403d..32ee96b86 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/NativeDateTimeResolver.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/NativeDateTimeResolver.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 using Datadog.Trace.Vendors.MessagePack.Formatters; using Datadog.Trace.Vendors.MessagePack.Internal; using System; diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/OldSpecResolver.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/OldSpecResolver.cs index bfc840535..bfb713d65 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/OldSpecResolver.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/OldSpecResolver.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 using Datadog.Trace.Vendors.MessagePack.Formatters; using Datadog.Trace.Vendors.MessagePack.Internal; using System; diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/PrimitiveObjectResolver.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/PrimitiveObjectResolver.cs index b37d0defd..a5b3ebd09 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/PrimitiveObjectResolver.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/PrimitiveObjectResolver.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 using Datadog.Trace.Vendors.MessagePack.Formatters; namespace Datadog.Trace.Vendors.MessagePack.Resolvers @@ -33,7 +34,7 @@ static FormatterCache() } } -//#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +//#if NETSTANDARD || NETFRAMEWORK // /// // /// In `object`, when serializing resolve by concrete type and when deserializing use primitive. diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/StandardResolver.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/StandardResolver.cs index 8cc04ece4..3cfa0ce70 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/StandardResolver.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/StandardResolver.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 using Datadog.Trace.Vendors.MessagePack.Formatters; using System.Linq; using Datadog.Trace.Vendors.MessagePack.Internal; @@ -16,7 +17,7 @@ internal sealed class StandardResolver : IFormatterResolver { public static readonly IFormatterResolver Instance = new StandardResolver(); -#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +#if NETSTANDARD || NETFRAMEWORK public static readonly IMessagePackFormatter ObjectFallbackFormatter = new DynamicObjectTypeFallbackFormatter(StandardResolverCore.Instance); #endif @@ -38,7 +39,7 @@ static FormatterCache() if (typeof(T) == typeof(object)) { // final fallback -#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +#if NETSTANDARD || NETFRAMEWORK formatter = (IMessagePackFormatter)ObjectFallbackFormatter; #else formatter = PrimitiveObjectResolver.Instance.GetFormatter(); @@ -56,7 +57,7 @@ internal sealed class ContractlessStandardResolver : IFormatterResolver { public static readonly IFormatterResolver Instance = new ContractlessStandardResolver(); -#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +#if NETSTANDARD || NETFRAMEWORK public static readonly IMessagePackFormatter ObjectFallbackFormatter = new DynamicObjectTypeFallbackFormatter(ContractlessStandardResolverCore.Instance); #endif @@ -78,7 +79,7 @@ static FormatterCache() if (typeof(T) == typeof(object)) { // final fallback -#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +#if NETSTANDARD || NETFRAMEWORK formatter = (IMessagePackFormatter)ObjectFallbackFormatter; #else formatter = PrimitiveObjectResolver.Instance.GetFormatter(); @@ -96,7 +97,7 @@ internal sealed class StandardResolverAllowPrivate : IFormatterResolver { public static readonly IFormatterResolver Instance = new StandardResolverAllowPrivate(); -#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +#if NETSTANDARD || NETFRAMEWORK public static readonly IMessagePackFormatter ObjectFallbackFormatter = new DynamicObjectTypeFallbackFormatter(StandardResolverAllowPrivateCore.Instance); #endif @@ -118,7 +119,7 @@ static FormatterCache() if (typeof(T) == typeof(object)) { // final fallback -#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +#if NETSTANDARD || NETFRAMEWORK formatter = (IMessagePackFormatter)ObjectFallbackFormatter; #else formatter = PrimitiveObjectResolver.Instance.GetFormatter(); @@ -136,7 +137,7 @@ internal sealed class ContractlessStandardResolverAllowPrivate : IFormatterResol { public static readonly IFormatterResolver Instance = new ContractlessStandardResolverAllowPrivate(); -#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +#if NETSTANDARD || NETFRAMEWORK public static readonly IMessagePackFormatter ObjectFallbackFormatter = new DynamicObjectTypeFallbackFormatter(ContractlessStandardResolverAllowPrivateCore.Instance); #endif @@ -158,7 +159,7 @@ static FormatterCache() if (typeof(T) == typeof(object)) { // final fallback -#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP +#if NETSTANDARD || NETFRAMEWORK formatter = (IMessagePackFormatter)ObjectFallbackFormatter; #else formatter = PrimitiveObjectResolver.Instance.GetFormatter(); @@ -188,7 +189,9 @@ internal static class StandardResolverHelper #if !ENABLE_IL2CPP && !UNITY_WSA && !NET_STANDARD_2_0 + DynamicEnumResolver.Instance, // Try Enum DynamicGenericResolver.Instance, // Try Array, Tuple, Collection + DynamicUnionResolver.Instance, // Try Union(Interface) #endif }; } @@ -200,6 +203,7 @@ internal sealed class StandardResolverCore : IFormatterResolver static readonly IFormatterResolver[] resolvers = StandardResolverHelper.DefaultResolvers.Concat(new IFormatterResolver[] { #if !ENABLE_IL2CPP && !UNITY_WSA && !NET_STANDARD_2_0 + DynamicObjectResolver.Instance, // Try Object #endif }).ToArray(); @@ -238,6 +242,8 @@ internal sealed class ContractlessStandardResolverCore : IFormatterResolver static readonly IFormatterResolver[] resolvers = StandardResolverHelper.DefaultResolvers.Concat(new IFormatterResolver[] { #if !ENABLE_IL2CPP && !UNITY_WSA && !NET_STANDARD_2_0 + DynamicObjectResolver.Instance, // Try Object + DynamicContractlessObjectResolver.Instance, // Serializes keys as strings #endif }).ToArray(); @@ -277,6 +283,7 @@ internal sealed class StandardResolverAllowPrivateCore : IFormatterResolver static readonly IFormatterResolver[] resolvers = StandardResolverHelper.DefaultResolvers.Concat(new IFormatterResolver[] { #if !ENABLE_IL2CPP && !UNITY_WSA && !NET_STANDARD_2_0 + DynamicObjectResolverAllowPrivate.Instance, // Try Object #endif }).ToArray(); @@ -315,6 +322,8 @@ internal sealed class ContractlessStandardResolverAllowPrivateCore : IFormatterR static readonly IFormatterResolver[] resolvers = StandardResolverHelper.DefaultResolvers.Concat(new IFormatterResolver[] { #if !ENABLE_IL2CPP && !UNITY_WSA && !NET_STANDARD_2_0 + DynamicObjectResolverAllowPrivate.Instance, // Try Object + DynamicContractlessObjectResolverAllowPrivate.Instance, // Serializes keys as strings #endif }).ToArray(); @@ -346,4 +355,4 @@ static FormatterCache() } } } -} +} \ No newline at end of file diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/TypelessContractlessStandardResolver.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/TypelessContractlessStandardResolver.cs new file mode 100644 index 000000000..914c8db52 --- /dev/null +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/TypelessContractlessStandardResolver.cs @@ -0,0 +1,62 @@ +//------------------------------------------------------------------------------ +// +// This file was automatically generated by the UpdateVendors tool. +//------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 +#if NETSTANDARD || NETFRAMEWORK +using Datadog.Trace.Vendors.MessagePack.Formatters; + +namespace Datadog.Trace.Vendors.MessagePack.Resolvers +{ + /// + /// Embed c# type names for `object` typed fields/collection items + /// Preserve c# DateTime timezone + /// + internal sealed class TypelessContractlessStandardResolver : IFormatterResolver + { + public static readonly IFormatterResolver Instance = new TypelessContractlessStandardResolver(); + + static readonly IFormatterResolver[] resolvers = new[] + { + NativeDateTimeResolver.Instance, // Native c# DateTime format, preserving timezone + BuiltinResolver.Instance, // Try Builtin + AttributeFormatterResolver.Instance, // Try use [MessagePackFormatter] +#if !ENABLE_IL2CPP + DynamicEnumResolver.Instance, // Try Enum + DynamicGenericResolver.Instance, // Try Array, Tuple, Collection + DynamicUnionResolver.Instance, // Try Union(Interface) + DynamicObjectResolver.Instance, // Try Object +#endif + DynamicContractlessObjectResolverAllowPrivate.Instance, // Serializes keys as strings + TypelessObjectResolver.Instance + }; + + TypelessContractlessStandardResolver() + { + } + + public IMessagePackFormatter GetFormatter() + { + return FormatterCache.formatter; + } + + static class FormatterCache + { + public static readonly IMessagePackFormatter formatter; + + static FormatterCache() + { + foreach (var item in resolvers) + { + var f = item.GetFormatter(); + if (f != null) + { + formatter = f; + return; + } + } + } + } + } +} +#endif \ No newline at end of file diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/TypelessObjectResolver.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/TypelessObjectResolver.cs new file mode 100644 index 000000000..ee6125c6f --- /dev/null +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/TypelessObjectResolver.cs @@ -0,0 +1,153 @@ +//------------------------------------------------------------------------------ +// +// This file was automatically generated by the UpdateVendors tool. +//------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 +using System; +using Datadog.Trace.Vendors.MessagePack.Formatters; +using System.Collections.Generic; +using Datadog.Trace.Vendors.MessagePack.Internal; + +namespace Datadog.Trace.Vendors.MessagePack.Resolvers +{ +#if NETSTANDARD || NETFRAMEWORK + + /// + /// Used for `object` fields/collections, ex: var arr = new object[] { 1, "a", new Model() }; + /// The runtime type of value in object field, should be covered by one of resolvers in complex/standard resolver. + /// TypelessObjectResolver should be placed before DynamicObjectTypeFallbackResolver and PrimitiveObjectFormatter in resolvers list. + /// Deserializer uses Namescape.TypeName, AssemblyName to get runtime type in destination app, so that combination must be present in destination app. + /// Serialized binary is valid MessagePack binary used ext-format and custom typecode(100). + /// Inside ext - assembly qualified type name, and serialized object + /// + internal sealed class TypelessObjectResolver : IFormatterResolver + { + public static IFormatterResolver Instance = new TypelessObjectResolver(); + + TypelessObjectResolver() + { + + } + + public IMessagePackFormatter GetFormatter() + { + return FormatterCache.formatter; + } + + static class FormatterCache + { + public static readonly IMessagePackFormatter formatter; + + static FormatterCache() + { + formatter = (typeof(T) == typeof(object)) + ? (IMessagePackFormatter)(object)TypelessFormatter.Instance + : null; + } + } + } + + // helpers for TypelessFormatter + + internal sealed class ForceSizePrimitiveObjectResolver : IFormatterResolver + { + public static IFormatterResolver Instance = new ForceSizePrimitiveObjectResolver(); + + ForceSizePrimitiveObjectResolver() + { + + } + + public IMessagePackFormatter GetFormatter() + { + return FormatterCache.formatter; + } + + static class FormatterCache + { + public static readonly IMessagePackFormatter formatter; + + static FormatterCache() + { + formatter = (IMessagePackFormatter)Helper.GetFormatter(typeof(T)); + } + } + + static class Helper + { + static readonly Dictionary formatterMap = new Dictionary() + { + // Primitive + {typeof(Int16), ForceInt16BlockFormatter.Instance}, + {typeof(Int32), ForceInt32BlockFormatter.Instance}, + {typeof(Int64), ForceInt64BlockFormatter.Instance}, + {typeof(UInt16), ForceUInt16BlockFormatter.Instance}, + {typeof(UInt32), ForceUInt32BlockFormatter.Instance}, + {typeof(UInt64), ForceUInt64BlockFormatter.Instance}, + {typeof(byte), ForceByteBlockFormatter.Instance}, + {typeof(sbyte), ForceSByteBlockFormatter.Instance}, + + // Nullable Primitive + {typeof(Nullable), NullableForceInt16BlockFormatter.Instance}, + {typeof(Nullable), NullableForceInt32BlockFormatter.Instance}, + {typeof(Nullable), NullableForceInt64BlockFormatter.Instance}, + {typeof(Nullable), NullableForceUInt16BlockFormatter.Instance}, + {typeof(Nullable), NullableForceUInt32BlockFormatter.Instance}, + {typeof(Nullable), NullableForceUInt64BlockFormatter.Instance}, + {typeof(Nullable), NullableForceByteBlockFormatter.Instance}, + {typeof(Nullable), NullableForceSByteBlockFormatter.Instance}, + + // optimized primitive array formatter + {typeof(Int16[]), ForceInt16BlockArrayFormatter.Instance}, + {typeof(Int32[]), ForceInt32BlockArrayFormatter.Instance}, + {typeof(Int64[]), ForceInt64BlockArrayFormatter.Instance}, + {typeof(UInt16[]), ForceUInt16BlockArrayFormatter.Instance}, + {typeof(UInt32[]), ForceUInt32BlockArrayFormatter.Instance}, + {typeof(UInt64[]), ForceUInt64BlockArrayFormatter.Instance}, + {typeof(SByte[]), ForceSByteBlockArrayFormatter.Instance}, + }; + + public static object GetFormatter(Type type) + { + object formatter; + return formatterMap.TryGetValue(type, out formatter) + ? formatter + : null; + } + } + } + + internal sealed class TypelessFormatterFallbackResolver : IFormatterResolver + { + public static IFormatterResolver Instance = new TypelessFormatterFallbackResolver(); + + static IMessagePackFormatter fallbackFormatter = new DynamicObjectTypeFallbackFormatter( + ForceSizePrimitiveObjectResolver.Instance, + ContractlessStandardResolverAllowPrivateCore.Instance); + + TypelessFormatterFallbackResolver() + { + + } + + public IMessagePackFormatter GetFormatter() + { + return FormatterCache.formatter; + } + + static class FormatterCache + { + public static readonly IMessagePackFormatter formatter; + + static FormatterCache() + { + if (typeof(T) == typeof(object)) + { + formatter = (IMessagePackFormatter)fallbackFormatter; + } + } + } + } + +#endif +} diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/UnsafeBinaryResolver.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/UnsafeBinaryResolver.cs new file mode 100644 index 000000000..f9e4dc3b7 --- /dev/null +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/Resolvers/UnsafeBinaryResolver.cs @@ -0,0 +1,68 @@ +//------------------------------------------------------------------------------ +// +// This file was automatically generated by the UpdateVendors tool. +//------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 +#if NETSTANDARD || NETFRAMEWORK + +using Datadog.Trace.Vendors.MessagePack.Formatters; +using Datadog.Trace.Vendors.MessagePack.Internal; +using System; + +namespace Datadog.Trace.Vendors.MessagePack.Resolvers +{ + internal sealed class UnsafeBinaryResolver : IFormatterResolver + { + public static readonly IFormatterResolver Instance = new UnsafeBinaryResolver(); + + UnsafeBinaryResolver() + { + + } + + public IMessagePackFormatter GetFormatter() + { + return FormatterCache.formatter; + } + + static class FormatterCache + { + public static readonly IMessagePackFormatter formatter; + + static FormatterCache() + { + formatter = (IMessagePackFormatter)UnsafeBinaryResolverGetFormatterHelper.GetFormatter(typeof(T)); + } + } + } +} + +namespace Datadog.Trace.Vendors.MessagePack.Internal +{ + internal static class UnsafeBinaryResolverGetFormatterHelper + { + internal static object GetFormatter(Type t) + { + if (t == typeof(Guid)) + { + return BinaryGuidFormatter.Instance; + } + else if (t == typeof(Guid?)) + { + return new StaticNullableFormatter(BinaryGuidFormatter.Instance); + } + else if (t == typeof(Decimal)) + { + return BinaryDecimalFormatter.Instance; + } + else if (t == typeof(Decimal?)) + { + return new StaticNullableFormatter(BinaryDecimalFormatter.Instance); + } + + return null; + } + } +} + +#endif \ No newline at end of file diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/StringEncoding.cs b/tracer/src/Datadog.Trace/Vendors/MessagePack/StringEncoding.cs index ed9fdd2d2..44f3ec56b 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/StringEncoding.cs +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/StringEncoding.cs @@ -2,6 +2,7 @@ // // This file was automatically generated by the UpdateVendors tool. //------------------------------------------------------------------------------ +#pragma warning disable CS0618, CS0649, CS1574, CS1580, CS1581, CS1584, CS1591, CS1573, CS8018, SYSLIB0011, SYSLIB0032 using System.Text; namespace Datadog.Trace.Vendors.MessagePack diff --git a/tracer/src/Datadog.Trace/Vendors/MessagePack/_last_downloaded_source_url.txt b/tracer/src/Datadog.Trace/Vendors/MessagePack/_last_downloaded_source_url.txt index 4efae849d..2fc6e480e 100644 --- a/tracer/src/Datadog.Trace/Vendors/MessagePack/_last_downloaded_source_url.txt +++ b/tracer/src/Datadog.Trace/Vendors/MessagePack/_last_downloaded_source_url.txt @@ -1 +1 @@ -https://github.com/neuecc/MessagePack-CSharp/archive/v1.9.3.zip \ No newline at end of file +https://github.com/neuecc/MessagePack-CSharp/archive/refs/tags/v1.9.11.zip \ No newline at end of file diff --git a/tracer/test/Datadog.Trace.Tests/ExtensionMethods/MessagePackBinaryExtensionsTests.cs b/tracer/test/Datadog.Trace.Tests/ExtensionMethods/MessagePackBinaryExtensionsTests.cs new file mode 100644 index 000000000..53f1fb096 --- /dev/null +++ b/tracer/test/Datadog.Trace.Tests/ExtensionMethods/MessagePackBinaryExtensionsTests.cs @@ -0,0 +1,107 @@ +// +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache 2 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2017 Datadog, Inc. +// + +#if NETCOREAPP3_1_OR_GREATER +using System; +using System.Collections.Generic; +using Datadog.Trace.Vendors.MessagePack; +using FluentAssertions; +using Xunit; + +namespace Datadog.Trace.Tests.ExtensionMethods +{ + public class MessagePackBinaryExtensionsTests + { + public static IEnumerable GetTestData() + { + var rnd = new Random(10); + foreach (var size in new[] { 1, 5, 50, 100, 500, 1000, 5000, 10000, 50000 }) + { + var values = new byte[size]; + rnd.NextBytes(values); + + for (var i = 0; i < 10; i++) + { + var offset = rnd.Next(size); + var count = size - offset; + yield return new object[] { values, offset, count }; + } + } + } + + [SkippableTheory] + [MemberData(nameof(GetTestData))] + public void WriteRawTest(byte[] values, int offset, int count) + { + // Declare MessagePack binary results + var resultExpected = new byte[0]; + var resultActual = new byte[0]; + + // Declare source data + var expectedSource = new byte[count]; + Buffer.BlockCopy(values, offset, expectedSource, 0, count); + + var actualSource = new ReadOnlySpan(values, offset, count); + + expectedSource.Should().Equal(actualSource.ToArray()); + + // Result + var expectedWritten = MessagePackBinary.WriteRaw(ref resultExpected, 0, expectedSource); + var actualWritten = MessagePackBinary.WriteRaw(ref resultActual, 0, actualSource); + + expectedWritten.Should().Be(actualWritten); + resultExpected.Should().Equal(resultActual); + } + + [SkippableTheory] + [MemberData(nameof(GetTestData))] + public void WriteBytesTest(byte[] values, int offset, int count) + { + // Declare MessagePack binary results + var resultExpected = new byte[0]; + var resultActual = new byte[0]; + + // Declare source data + var expectedSource = new byte[count]; + Buffer.BlockCopy(values, offset, expectedSource, 0, count); + + var actualSource = new ReadOnlySpan(values, offset, count); + + expectedSource.Should().Equal(actualSource.ToArray()); + + // Result + var expectedWritten = MessagePackBinary.WriteBytes(ref resultExpected, 0, expectedSource); + var actualWritten = MessagePackBinary.WriteBytes(ref resultActual, 0, actualSource); + + expectedWritten.Should().Be(actualWritten); + resultExpected.Should().Equal(resultActual); + } + + [SkippableTheory] + [MemberData(nameof(GetTestData))] + public void WriteStringBytesTest(byte[] values, int offset, int count) + { + // Declare MessagePack binary results + var resultExpected = new byte[0]; + var resultActual = new byte[0]; + + // Declare source data + var expectedSource = new byte[count]; + Buffer.BlockCopy(values, offset, expectedSource, 0, count); + + var actualSource = new ReadOnlySpan(values, offset, count); + + expectedSource.Should().Equal(actualSource.ToArray()); + + // Result + var expectedWritten = MessagePackBinary.WriteStringBytes(ref resultExpected, 0, expectedSource); + var actualWritten = MessagePackBinary.WriteStringBytes(ref resultActual, 0, actualSource); + + expectedWritten.Should().Be(actualWritten); + resultExpected.Should().Equal(resultActual); + } + } +} +#endif diff --git a/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.Datadog.Trace.AssemblyReferencesHaveNotChanged.net461.verified.txt b/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.Datadog.Trace.AssemblyReferencesHaveNotChanged.net461.verified.txt index ae62b079b..bf667f06e 100644 --- a/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.Datadog.Trace.AssemblyReferencesHaveNotChanged.net461.verified.txt +++ b/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.Datadog.Trace.AssemblyReferencesHaveNotChanged.net461.verified.txt @@ -4,5 +4,6 @@ System.Configuration, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f1 System.Core, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Data, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Numerics, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 +System.Runtime.Serialization, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Web, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a System.Xml, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 diff --git a/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.Datadog.Trace.AssemblyReferencesHaveNotChanged.net6.0.verified.txt b/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.Datadog.Trace.AssemblyReferencesHaveNotChanged.net6.0.verified.txt index 3e49d971a..61a257b02 100644 --- a/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.Datadog.Trace.AssemblyReferencesHaveNotChanged.net6.0.verified.txt +++ b/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.Datadog.Trace.AssemblyReferencesHaveNotChanged.net6.0.verified.txt @@ -41,6 +41,7 @@ System.Runtime.InteropServices.RuntimeInformation, Version=6.0.0.0, Culture=neut System.Runtime.Loader, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a System.Runtime.Numerics, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a System.Runtime.Serialization.Formatters, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a +System.Runtime.Serialization.Primitives, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a System.Security.Cryptography.Algorithms, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a System.Security.Cryptography.Primitives, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a System.Text.Encoding.Extensions, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a diff --git a/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.Datadog.Trace.AssemblyReferencesHaveNotChanged.netcoreapp3.1.verified.txt b/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.Datadog.Trace.AssemblyReferencesHaveNotChanged.netcoreapp3.1.verified.txt index 10fb0ce95..e138bd171 100644 --- a/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.Datadog.Trace.AssemblyReferencesHaveNotChanged.netcoreapp3.1.verified.txt +++ b/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.Datadog.Trace.AssemblyReferencesHaveNotChanged.netcoreapp3.1.verified.txt @@ -1,4 +1,5 @@ Microsoft.AspNetCore.Http.Abstractions, Version=2.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60 +Microsoft.AspNetCore.Http.Extensions, Version=2.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60 Microsoft.AspNetCore.Http.Features, Version=2.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60 Microsoft.AspNetCore.Mvc.Abstractions, Version=2.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60 Microsoft.AspNetCore.Routing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60 @@ -44,6 +45,7 @@ System.Runtime.InteropServices.RuntimeInformation, Version=4.0.4.0, Culture=neut System.Runtime.Loader, Version=4.1.1.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a System.Runtime.Numerics, Version=4.1.2.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a System.Runtime.Serialization.Formatters, Version=4.0.4.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a +System.Runtime.Serialization.Primitives, Version=4.2.2.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a System.Security.Cryptography.Algorithms, Version=4.3.2.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a System.Security.Cryptography.Primitives, Version=4.1.2.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a System.Text.Encoding.Extensions, Version=4.1.2.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a diff --git a/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.SignalFx.Tracing.AssemblyReferencesHaveNotChanged.net461.verified.txt b/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.SignalFx.Tracing.AssemblyReferencesHaveNotChanged.net461.verified.txt index ae62b079b..bf667f06e 100644 --- a/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.SignalFx.Tracing.AssemblyReferencesHaveNotChanged.net461.verified.txt +++ b/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.SignalFx.Tracing.AssemblyReferencesHaveNotChanged.net461.verified.txt @@ -4,5 +4,6 @@ System.Configuration, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f1 System.Core, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Data, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Numerics, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 +System.Runtime.Serialization, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Web, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a System.Xml, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 diff --git a/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.SignalFx.Tracing.AssemblyReferencesHaveNotChanged.net6.0.verified.txt b/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.SignalFx.Tracing.AssemblyReferencesHaveNotChanged.net6.0.verified.txt index 3e49d971a..61a257b02 100644 --- a/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.SignalFx.Tracing.AssemblyReferencesHaveNotChanged.net6.0.verified.txt +++ b/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.SignalFx.Tracing.AssemblyReferencesHaveNotChanged.net6.0.verified.txt @@ -41,6 +41,7 @@ System.Runtime.InteropServices.RuntimeInformation, Version=6.0.0.0, Culture=neut System.Runtime.Loader, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a System.Runtime.Numerics, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a System.Runtime.Serialization.Formatters, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a +System.Runtime.Serialization.Primitives, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a System.Security.Cryptography.Algorithms, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a System.Security.Cryptography.Primitives, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a System.Text.Encoding.Extensions, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a diff --git a/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.SignalFx.Tracing.AssemblyReferencesHaveNotChanged.netcoreapp3.1.verified.txt b/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.SignalFx.Tracing.AssemblyReferencesHaveNotChanged.netcoreapp3.1.verified.txt index 10fb0ce95..1c0aa8036 100644 --- a/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.SignalFx.Tracing.AssemblyReferencesHaveNotChanged.netcoreapp3.1.verified.txt +++ b/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.SignalFx.Tracing.AssemblyReferencesHaveNotChanged.netcoreapp3.1.verified.txt @@ -44,6 +44,7 @@ System.Runtime.InteropServices.RuntimeInformation, Version=4.0.4.0, Culture=neut System.Runtime.Loader, Version=4.1.1.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a System.Runtime.Numerics, Version=4.1.2.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a System.Runtime.Serialization.Formatters, Version=4.0.4.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a +System.Runtime.Serialization.Primitives, Version=4.2.2.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a System.Security.Cryptography.Algorithms, Version=4.3.2.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a System.Security.Cryptography.Primitives, Version=4.1.2.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a System.Text.Encoding.Extensions, Version=4.1.2.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a