static void EmitDeserializeValue( ILGenerator il, DeserializeInfo info, int index, ArgumentField argReader, ArgumentField argOptions, LocalBuilder localResolver ) { Label storeLabel = il.DefineLabel(); UnionSerializationInfo.EmittableMember member = info.MemberInfo; Type t = member.Type; if (IsOptimizeTargetType(t)) { if (!t.GetTypeInfo().IsValueType) { // As a nullable type (e.g. byte[] and string) we need to first call TryReadNil // if (reader.TryReadNil()) Label readNonNilValueLabel = il.DefineLabel(); argReader.EmitLdarg(); il.EmitCall(MessagePackReaderTypeInfo.TryReadNil); il.Emit(OpCodes.Brfalse_S, readNonNilValueLabel); il.Emit(OpCodes.Ldnull); il.Emit(OpCodes.Br, storeLabel); il.MarkLabel(readNonNilValueLabel); } argReader.EmitLdarg(); if (t == typeof(byte[])) { LocalBuilder local = il.DeclareLocal(typeof(ReadOnlySequence <byte>?)); il.EmitCall(MessagePackReaderTypeInfo.ReadBytes); il.EmitStloc(local); il.EmitLdloca(local); il.EmitCall(ArrayFromNullableReadOnlySequence); } else { il.EmitCall(MessagePackReaderTypeInfo.TypeInfo.GetDeclaredMethods("Read" + t.Name).First(x => x.GetParameters().Length == 0)); } } else { il.EmitLdloc(localResolver); il.EmitCall(getFormatterWithVerify.MakeGenericMethod(t)); argReader.EmitLdarg(); argOptions.EmitLoad(); il.EmitCall(getDeserialize(t)); } il.MarkLabel(storeLabel); il.EmitStloc(info.LocalField); }
static LocalBuilder EmitNewObject <TFrom, TTo>(ILGenerator il, ArgumentField fromValue, MetaConstructorInfo <TFrom, TTo> metaConstructorInfo) { var toType = typeof(TTo); var result = il.DeclareLocal(toType); if (toType.IsClass) { if (metaConstructorInfo == null || metaConstructorInfo.ConstructorInfo == null) { throw new InvalidOperationException("ConstructorInfo does not find, " + typeof(TFrom) + " -> " + typeof(TTo) + " Mapper."); } foreach (var item in metaConstructorInfo.Arguments) { fromValue.EmitLoad(); item.EmitLoadValue(il); } il.Emit(OpCodes.Newobj, metaConstructorInfo.ConstructorInfo); il.EmitStloc(result); } else { if (metaConstructorInfo == null || metaConstructorInfo.ConstructorInfo == null) { il.Emit(OpCodes.Ldloca, result); il.Emit(OpCodes.Initobj, toType); } else { foreach (var item in metaConstructorInfo.Arguments) { fromValue.EmitLoad(); item.EmitLoadValue(il); } il.Emit(OpCodes.Newobj, metaConstructorInfo.ConstructorInfo); il.EmitStloc(result); } } return(result); }
static void BuildMap <TFrom, TTo>(ILGenerator il, MappingInfo <TFrom, TTo> mappingInfo, int firstArgIndex, Action emitBeforeMapLoadDelegate, Action emitAfterMapLoadDelegate, Dictionary <MetaMemberPair <TFrom, TTo>, FieldBuilder> convertActionDictionary) { var fromType = typeof(TFrom); var toType = typeof(TTo); var argFrom = new ArgumentField(il, firstArgIndex, fromType); var argResolver = new ArgumentField(il, firstArgIndex + 1); // call beforeMap if (mappingInfo.BeforeMap != null) { emitBeforeMapLoadDelegate(); argFrom.EmitLdarg(); il.EmitCall(EmitInfo.GetActionInvoke <TFrom>()); } // if(from == null) return null if (!fromType.IsValueType) { var gotoNextLabel = il.DefineLabel(); argFrom.EmitLoad(); il.Emit(OpCodes.Brtrue_S, gotoNextLabel); il.Emit(OpCodes.Ldnull); il.Emit(OpCodes.Ret); il.MarkLabel(gotoNextLabel); } // construct totype var result = EmitNewObject <TFrom, TTo>(il, argFrom, mappingInfo.TargetConstructor); // map from -> to. foreach (var item in mappingInfo.TargetMembers) { EmitMapMember(il, item, argFrom, argResolver, result, convertActionDictionary); } // call afterMap if (mappingInfo.AfterMap != null) { emitAfterMapLoadDelegate(); il.EmitLdloc(result); il.EmitCall(EmitInfo.GetActionInvoke <TTo>()); } // end. il.EmitLdloc(result); il.Emit(OpCodes.Ret); }
static void EmitDeserializeUnionCase( ILGenerator il, Type type, UnionSerializationInfo info, LocalBuilder unionKey, FieldBuilder stringByteKeysField, ArgumentField reader, ArgumentField argOptions, LocalBuilder localResolver ) { // options.Security.DepthStep(ref reader); argOptions.EmitLoad(); il.EmitCall(getSecurityFromOptions); reader.EmitLdarg(); il.EmitCall(securityDepthStep); // var length = ReadMapHeader(ref byteSequence); LocalBuilder length = il.DeclareLocal(typeof(int)); // [loc:1] reader.EmitLdarg(); if (info.IsIntKey) { il.EmitCall(MessagePackReaderTypeInfo.ReadArrayHeader); } else { il.EmitCall(MessagePackReaderTypeInfo.ReadMapHeader); } il.EmitStloc(length); // 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 => { UnionSerializationInfo.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(); } // 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); } LocalBuilder buffer = il.DeclareLocal(typeof(ReadOnlySpan <byte>)); LocalBuilder longKey = il.DeclareLocal(typeof(ulong)); // for (int i = 0; i < len; i++) il.EmitIncrementFor(length, forILocal => { Label readNext = il.DefineLabel(); Label loopEnd = il.DefineLabel(); reader.EmitLdarg(); il.EmitCall(ReadStringSpan); il.EmitStloc(buffer); // gen automata name lookup automata.EmitMatch( il, buffer, longKey, x => { var i = x.Value; if (infoList[i].MemberInfo != null) { EmitDeserializeValue(il, infoList[i], i, reader, argOptions, localResolver); il.Emit(OpCodes.Br, loopEnd); } else { il.Emit(OpCodes.Br, readNext); } }, () => { il.Emit(OpCodes.Br, readNext); }); il.MarkLabel(readNext); reader.EmitLdarg(); il.EmitCall(MessagePackReaderTypeInfo.Skip); il.MarkLabel(loopEnd); }); } else { LocalBuilder key = il.DeclareLocal(typeof(int)); Label switchDefault = il.DefineLabel(); il.EmitIncrementFor(length, forILocal => { Label 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. reader.ReadNextBlock(); reader.EmitLdarg(); il.EmitCall(MessagePackReaderTypeInfo.Skip); il.Emit(OpCodes.Br, loopEnd); if (gotoDefault != null) { il.MarkLabel(gotoDefault.Value); il.Emit(OpCodes.Br, switchDefault); } var i = 0; foreach (DeserializeInfo item in infoList) { if (item.MemberInfo != null) { il.MarkLabel(item.SwitchLabel); EmitDeserializeValue(il, item, i++, reader, argOptions, localResolver); il.Emit(OpCodes.Br, loopEnd); } } il.MarkLabel(loopEnd); }); } // create result union case LocalBuilder 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); } } // reader.Depth--; reader.EmitLdarg(); il.Emit(OpCodes.Dup); il.EmitCall(readerDepthGet); il.Emit(OpCodes.Ldc_I4_1); il.Emit(OpCodes.Sub_Ovf); il.EmitCall(readerDepthSet); if (info.IsStruct) { il.Emit(OpCodes.Ldloc, structLocal); } }
static void EmitSerializeValue( ILGenerator il, TypeInfo type, UnionSerializationInfo.EmittableMember member, int index, ArgumentField argWriter, ArgumentField argValue, ArgumentField argOptions, LocalBuilder localResolver ) { Label endLabel = il.DefineLabel(); Type t = member.Type; if (IsOptimizeTargetType(t)) { if (!t.GetTypeInfo().IsValueType) { // As a nullable type (e.g. byte[] and string) we need to call WriteNil for null values. Label writeNonNilValueLabel = il.DefineLabel(); LocalBuilder memberValue = il.DeclareLocal(t); argValue.EmitLoad(); member.EmitLoadValue(il); il.Emit(OpCodes.Dup); il.EmitStloc(memberValue); il.Emit(OpCodes.Brtrue, writeNonNilValueLabel); argWriter.EmitLoad(); il.EmitCall(MessagePackWriterTypeInfo.WriteNil); il.Emit(OpCodes.Br, endLabel); il.MarkLabel(writeNonNilValueLabel); argWriter.EmitLoad(); il.EmitLdloc(memberValue); } else { argWriter.EmitLoad(); argValue.EmitLoad(); member.EmitLoadValue(il); } if (t == typeof(byte[])) { il.EmitCall(ReadOnlySpanFromByteArray); il.EmitCall(MessagePackWriterTypeInfo.WriteBytes); } else { il.EmitCall(typeof(MessagePackWriter).GetRuntimeMethod("Write", new Type[] { t })); } } else { il.EmitLdloc(localResolver); il.Emit(OpCodes.Call, getFormatterWithVerify.MakeGenericMethod(t)); argWriter.EmitLoad(); argValue.EmitLoad(); member.EmitLoadValue(il); argOptions.EmitLoad(); il.EmitCall(getSerialize(t)); } il.MarkLabel(endLabel); }
static void EmitSerializeUnionCase( ILGenerator il, Type type, TypeInfo ti, UnionSerializationInfo info, FieldBuilder stringByteKeysField, ArgumentField argWriter, ArgumentField argValue, ArgumentField argOptions, LocalBuilder localResolver ) { if (info.IsIntKey) { // use Array var maxKey = info.Members.Select(x => x.IntKey).DefaultIfEmpty(-1).Max(); var intKeyMap = info.Members.ToDictionary(x => x.IntKey); var len = maxKey + 1; argWriter.EmitLoad(); il.EmitLdc_I4(len); il.EmitCall(MessagePackWriterTypeInfo.WriteArrayHeader); var index = 0; for (int i = 0; i <= maxKey; i++) { UnionSerializationInfo.EmittableMember member; if (intKeyMap.TryGetValue(i, out member)) { EmitSerializeValue(il, ti, member, index++, argWriter, argValue, argOptions, localResolver); } else { // Write Nil as Blanc argWriter.EmitLoad(); il.EmitCall(MessagePackWriterTypeInfo.WriteNil); } } } else { // use Map var writeCount = info.Members.Count(); argWriter.EmitLoad(); il.EmitLdc_I4(writeCount); ////if (writeCount <= MessagePackRange.MaxFixMapCount) ////{ //// il.EmitCall(MessagePackWriterTypeInfo.WriteFixedMapHeaderUnsafe); ////} ////else { il.EmitCall(MessagePackWriterTypeInfo.WriteMapHeader); } var index = 0; foreach (UnionSerializationInfo.EmittableMember item in info.Members) { argWriter.EmitLoad(); il.EmitLoadThis(); il.EmitLdfld(stringByteKeysField); il.EmitLdc_I4(index); il.Emit(OpCodes.Ldelem_Ref); il.Emit(OpCodes.Call, ReadOnlySpanFromByteArray); // convert byte[] to ReadOnlySpan<byte> // Optimize, WriteRaw(Unity, large) or UnsafeMemory32/64.WriteRawX var valueLen = CodeGenHelpers.GetEncodedStringBytes(item.StringKey).Length; if (valueLen <= MessagePackRange.MaxFixStringLength) { if (UnsafeMemory.Is32Bit) { il.EmitCall(typeof(UnsafeMemory32).GetRuntimeMethod("WriteRaw" + valueLen, new[] { typeof(MessagePackWriter).MakeByRefType(), typeof(ReadOnlySpan <byte>) })); } else { il.EmitCall(typeof(UnsafeMemory64).GetRuntimeMethod("WriteRaw" + valueLen, new[] { typeof(MessagePackWriter).MakeByRefType(), typeof(ReadOnlySpan <byte>) })); } } else { il.EmitCall(MessagePackWriterTypeInfo.WriteRaw); } EmitSerializeValue(il, type.GetTypeInfo(), item, index, argWriter, argValue, argOptions, localResolver); index++; } } }
// void Serialize(ref [arg:1]MessagePackWriter writer, [arg:2]T value, [arg:3]MessagePackSerializerOptions options); static void BuildSerialize( Type type, UnionCaseInfo[] infos, MethodBuilder method, FieldBuilder[] stringByteKeysFields, ILGenerator il, int firstArgIndex ) { var tag = getTag(type); var ti = type.GetTypeInfo(); var argWriter = new ArgumentField(il, firstArgIndex); var argValue = new ArgumentField(il, firstArgIndex + 1, type); var argOptions = new ArgumentField(il, firstArgIndex + 2); // if(value == null) return WriteNil if (ti.IsClass) { Label elseBody = il.DefineLabel(); argValue.EmitLoad(); il.Emit(OpCodes.Brtrue_S, elseBody); argWriter.EmitLoad(); il.EmitCall(MessagePackWriterTypeInfo.WriteNil); il.Emit(OpCodes.Ret); il.MarkLabel(elseBody); } // IMessagePackSerializationCallbackReceiver.OnBeforeSerialize() if (ti.ImplementedInterfaces.Any(x => x == typeof(IMessagePackSerializationCallbackReceiver))) { // call directly MethodInfo[] 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); } } // IFormatterResolver resolver = options.Resolver; LocalBuilder localResolver = il.DeclareLocal(typeof(IFormatterResolver)); argOptions.EmitLoad(); il.EmitCall(getResolverFromOptions); il.EmitStloc(localResolver); // writer.WriteArrayHeader(2, false); argWriter.EmitLdarg(); il.EmitLdc_I4(2); il.EmitCall(MessagePackWriterTypeInfo.WriteArrayHeader); // writer.Write(value.Tag) argWriter.EmitLdarg(); if (ti.IsClass) { argValue.EmitLdarg(); } else { argValue.EmitLdarga(); } il.EmitCall(tag); il.EmitCall(MessagePackWriterTypeInfo.WriteInt32); var loopEnd = il.DefineLabel(); // switch-case (offset += resolver.GetFormatter.Serialize(with cast) var switchLabels = infos.Select(x => new { Label = il.DefineLabel(), Info = x }).ToArray(); if (ti.IsClass) { argValue.EmitLdarg(); } else { argValue.EmitLdarga(); } il.EmitCall(tag); 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); EmitSerializeUnionCase( il, type, ti, UnionSerializationInfo.CreateOrNull(type, item.Info), stringByteKeysFields[item.Info.Tag], argWriter, argValue, argOptions, localResolver ); il.Emit(OpCodes.Br, loopEnd); } // return; il.MarkLabel(loopEnd); il.Emit(OpCodes.Ret); }
static void EmitMapMember <TFrom, TTo>(ILGenerator il, MetaMemberPair <TFrom, TTo> pair, ArgumentField argFrom, ArgumentField argResolver, LocalBuilder toLocal, Dictionary <MetaMemberPair <TFrom, TTo>, FieldBuilder> convertFields) { if (pair.From == null) { // To and conversion pattern(Func<TFrom, TFromMember>). if (toLocal.LocalType.IsValueType) { il.EmitLdloca(toLocal); } else { il.EmitLdloc(toLocal); } // note: if use DynamicMethod, should change field to argument. // Func[TFrom, TToMember] var convertField = convertFields[pair]; il.EmitLoadThis(); il.EmitLdfld(convertField); il.Emit(OpCodes.Castclass, typeof(Func <,>).MakeGenericType(typeof(TFrom), pair.To.Type)); argFrom.EmitLdarg(); il.EmitCall(EmitInfo.GetFuncInvokeDynamic(typeof(TFrom), pair.To.Type)); pair.To.EmitStoreValue(il); } else { // optimize for primitive to primitive if (pair.From.Type == pair.To.Type) { if (optimizeInliningType.Contains(pair.To.Type)) { if (toLocal.LocalType.IsValueType) { il.EmitLdloca(toLocal); } else { il.EmitLdloc(toLocal); } if (convertFields.TryGetValue(pair, out var convertField)) { il.EmitLoadThis(); il.EmitLdfld(convertField); il.Emit(OpCodes.Castclass, typeof(Func <,>).MakeGenericType(pair.From.Type, pair.To.Type)); } argFrom.EmitLoad(); pair.From.EmitLoadValue(il); if (convertField != null) { il.EmitCall(EmitInfo.GetFuncInvokeDynamic(pair.From.Type, pair.To.Type)); } pair.To.EmitStoreValue(il); return; } // more aggressive inlining for primitive[] if (pair.To.Type.IsArray) { var elemType = pair.To.Type.GetElementType(); var mapMethodInfo = EmitInfo.GetMemoryCopyMapperMap(elemType); if (mapMethodInfo != null) { il.EmitLdloc(toLocal); if (convertFields.TryGetValue(pair, out var convertField)) { il.EmitLoadThis(); il.EmitLdfld(convertField); il.Emit(OpCodes.Castclass, typeof(Func <,>).MakeGenericType(pair.From.Type, pair.To.Type)); } argFrom.EmitLoad(); pair.From.EmitLoadValue(il); il.EmitCall(mapMethodInfo); if (convertField != null) { il.EmitCall(EmitInfo.GetFuncInvokeDynamic(pair.From.Type, pair.To.Type)); } pair.To.EmitStoreValue(il); return; } } } // standard mapping(Mapper.Map) { if (toLocal.LocalType.IsValueType) { il.EmitLdloca(toLocal); } else { il.EmitLdloc(toLocal); } if (convertFields.TryGetValue(pair, out var convertField)) { il.EmitLoadThis(); il.EmitLdfld(convertField); il.Emit(OpCodes.Castclass, typeof(Func <,>).MakeGenericType(pair.From.Type, pair.To.Type)); } argResolver.EmitLoad(); il.EmitCall(EmitInfo.GetGetMapperWithVerifyDynamic(pair.From.Type, pair.To.Type)); argFrom.EmitLoad(); pair.From.EmitLoadValue(il); argResolver.EmitLoad(); il.EmitCall(EmitInfo.GetMapDynamic(pair.From.Type, pair.To.Type)); if (convertField != null) { il.EmitCall(EmitInfo.GetFuncInvokeDynamic(pair.From.Type, pair.To.Type)); } pair.To.EmitStoreValue(il); } } }