protected internal override void VisitCallVirt(CallVirt inst) { HandleCall(inst); }
protected internal override void VisitCallVirt(CallVirt inst) { base.VisitCallVirt(inst); TransformAssignment.HandleCallCompoundAssign(inst, context); }
protected override void VisitCallVirt(CallVirt inst) => MapCall(inst);
private int EmulateInstruction(Instruction instruction, int i) { switch (instruction.OpCode.Code) { case Code.UNKNOWN1: throw new NotSupportedException(); case Code.UNKNOWN2: throw new NotSupportedException(); case Code.Add: Add.Emulate(ValueStack); break; case Code.Add_Ovf: case Code.Add_Ovf_Un: Add.Emulate_Ovf(ValueStack); break; case Code.And: And.Emulate(ValueStack); break; case Code.Arglist: throw new NotSupportedException(); case Code.Beq: case Code.Beq_S: var beqResult = Beq.Emulate(ValueStack, instruction, _instructionsToEmulate); return(beqResult == -1 ? i : beqResult); case Code.Bge: case Code.Bge_S: case Code.Bge_Un: case Code.Bge_Un_S: var bgeResult = Bge.Emulate(ValueStack, instruction, _instructionsToEmulate); return(bgeResult == -1 ? i : bgeResult); case Code.Bgt: case Code.Bgt_S: case Code.Bgt_Un: case Code.Bgt_Un_S: var bgtResult = Bgt.Emulate(ValueStack, instruction, _instructionsToEmulate); return(bgtResult == -1 ? i : bgtResult); case Code.Ble: case Code.Ble_S: case Code.Ble_Un: case Code.Ble_Un_S: var bleResult = Ble.Emulate(ValueStack, instruction, _instructionsToEmulate); return(bleResult == -1 ? i : bleResult); case Code.Blt: case Code.Blt_S: case Code.Blt_Un: case Code.Blt_Un_S: var bltResult = Blt.Emulate(ValueStack, instruction, _instructionsToEmulate); return(bltResult == -1 ? i : bltResult); case Code.Bne_Un: case Code.Bne_Un_S: var bneResult = Bne.Emulate(ValueStack, instruction, _instructionsToEmulate); return(bneResult == -1 ? i : bneResult); case Code.Box: Box.Emulate_Box(ValueStack, instruction); break; case Code.Br: case Code.Br_S: return(Br.Emulate(ValueStack, instruction, _instructionsToEmulate)); case Code.Break: break; case Code.Brfalse: case Code.Brfalse_S: var bFalseResult = BrFalse.Emulate(ValueStack, instruction, _instructionsToEmulate); return(bFalseResult == -1 ? i : bFalseResult); case Code.Brtrue: case Code.Brtrue_S: var bTrueResult = BrTrue.Emulate(ValueStack, instruction, _instructionsToEmulate); return(bTrueResult == -1 ? i : bTrueResult); case Code.Call: Call.Emulate(ValueStack, instruction, _method); break; case Code.Calli: throw new NotSupportedException(); case Code.Callvirt: CallVirt.Emulate(ValueStack, instruction, _method); break; case Code.Castclass: CastClass.Emulate(ValueStack, instruction); break; case Code.Ceq: Ceq.Emulate(ValueStack); break; case Code.Cgt: case Code.Cgt_Un: Ceq.Emulate(ValueStack); break; case Code.Ckfinite: throw new NotSupportedException(); case Code.Clt: case Code.Clt_Un: Clt.Emulate(ValueStack); break; case Code.Constrained: throw new NotSupportedException(); case Code.Conv_I: ConvI.Emulation(ValueStack); break; case Code.Conv_I1: throw new NotSupportedException(); case Code.Conv_I2: ConvI2.Emulation(ValueStack); break; case Code.Conv_I4: ConvI4.Emulation(ValueStack); break; case Code.Conv_I8: ConvI8.Emulation(ValueStack); break; case Code.Conv_Ovf_I: throw new NotSupportedException(); case Code.Conv_Ovf_I_Un: throw new NotSupportedException(); case Code.Conv_Ovf_I1: throw new NotSupportedException(); case Code.Conv_Ovf_I1_Un: throw new NotSupportedException(); case Code.Conv_Ovf_I2: throw new NotSupportedException(); case Code.Conv_Ovf_I2_Un: throw new NotSupportedException(); case Code.Conv_Ovf_I4: throw new NotSupportedException(); case Code.Conv_Ovf_I4_Un: throw new NotSupportedException(); case Code.Conv_Ovf_I8: throw new NotSupportedException(); case Code.Conv_Ovf_I8_Un: throw new NotSupportedException(); case Code.Conv_Ovf_U: throw new NotSupportedException(); case Code.Conv_Ovf_U_Un: throw new NotSupportedException(); case Code.Conv_Ovf_U1: throw new NotSupportedException(); case Code.Conv_Ovf_U1_Un: throw new NotSupportedException(); case Code.Conv_Ovf_U2: throw new NotSupportedException(); case Code.Conv_Ovf_U2_Un: throw new NotSupportedException(); case Code.Conv_Ovf_U4: throw new NotSupportedException(); case Code.Conv_Ovf_U4_Un: throw new NotSupportedException(); case Code.Conv_Ovf_U8: throw new NotSupportedException(); case Code.Conv_Ovf_U8_Un: throw new NotSupportedException(); case Code.Conv_R_Un: throw new NotSupportedException(); case Code.Conv_R4: throw new NotSupportedException(); case Code.Conv_R8: throw new NotSupportedException(); case Code.Conv_U: ConvI.UEmulation(ValueStack); break; case Code.Conv_U1: ConvI1.UEmulation(ValueStack); break; case Code.Conv_U2: ConvI2.UEmulation(ValueStack); break; case Code.Conv_U4: ConvI4.UEmulation(ValueStack); break; case Code.Conv_U8: ConvI8.UEmulation(ValueStack); break; case Code.Cpblk: throw new NotSupportedException(); case Code.Cpobj: throw new NotSupportedException(); case Code.Div: Div.Emulate(ValueStack); break; case Code.Div_Un: Div.Emulate_Un(ValueStack); break; case Code.Dup: ValueStack.CallStack.Push(ValueStack.CallStack.Peek()); break; case Code.Endfilter: throw new NotSupportedException(); case Code.Endfinally: throw new NotSupportedException(); case Code.Initblk: throw new NotSupportedException(); case Code.Initobj: ValueStack.CallStack.Pop(); break; case Code.Isinst: IsInst.Emulate_Box(ValueStack, instruction); break; case Code.Jmp: throw new NotSupportedException(); case Code.Ldarg: case Code.Ldarg_0: case Code.Ldarg_1: case Code.Ldarg_2: case Code.Ldarg_3: case Code.Ldarg_S: Ldarg.Emulate(ValueStack, instruction, _method); break; case Code.Ldarga: throw new NotSupportedException(); case Code.Ldarga_S: throw new NotSupportedException(); case Code.Ldc_I4: case Code.Ldc_I4_0: case Code.Ldc_I4_1: case Code.Ldc_I4_2: case Code.Ldc_I4_3: case Code.Ldc_I4_4: case Code.Ldc_I4_5: case Code.Ldc_I4_6: case Code.Ldc_I4_7: case Code.Ldc_I4_8: ValueStack.CallStack.Push(instruction.GetLdcI4Value()); break; case Code.Ldc_I4_M1: ValueStack.CallStack.Push(-1); break; case Code.Ldc_I4_S: ValueStack.CallStack.Push((sbyte)instruction.GetLdcI4Value()); break; case Code.Ldc_I8: ValueStack.CallStack.Push((long)instruction.Operand); break; case Code.Ldc_R4: ValueStack.CallStack.Push((float)instruction.GetOperand()); break; case Code.Ldc_R8: ValueStack.CallStack.Push((double)instruction.GetOperand()); break; case Code.Ldelem: throw new NotSupportedException(); case Code.Ldelem_I: throw new NotSupportedException(); case Code.Ldelem_I1: throw new NotSupportedException(); case Code.Ldelem_I2: throw new NotSupportedException(); case Code.Ldelem_I4: throw new NotSupportedException(); case Code.Ldelem_I8: throw new NotSupportedException(); case Code.Ldelem_R4: throw new NotSupportedException(); case Code.Ldelem_R8: throw new NotSupportedException(); case Code.Ldelem_Ref: LdelemRef.Emulate(ValueStack); break; case Code.Ldelem_U1: LdelemI1.UEmulate(ValueStack); break; case Code.Ldelem_U2: throw new NotSupportedException(); case Code.Ldelem_U4: LdelemI4.UEmulate(ValueStack); break; case Code.Ldelema: Ldelema.Emulate(ValueStack); break; case Code.Ldfld: throw new NotSupportedException(); case Code.Ldflda: throw new NotSupportedException(); case Code.Ldftn: throw new NotSupportedException(); case Code.Ldind_I: throw new NotSupportedException(); case Code.Ldind_I1: throw new NotSupportedException(); case Code.Ldind_I2: throw new NotSupportedException(); case Code.Ldind_I4: LdindI4.Emulate(ValueStack); break; case Code.Ldind_I8: throw new NotSupportedException(); case Code.Ldind_R4: throw new NotSupportedException(); case Code.Ldind_R8: throw new NotSupportedException(); case Code.Ldind_Ref: throw new NotSupportedException(); case Code.Ldind_U1: LdindI1.UEmulate(ValueStack); break; case Code.Ldind_U2: LdindI2.UEmulate(ValueStack); break; case Code.Ldind_U4: LdindI4.UEmulate(ValueStack); break; case Code.Ldlen: Ldlen.Emulate(ValueStack); break; case Code.Ldloc: case Code.Ldloc_0: case Code.Ldloc_1: case Code.Ldloc_2: case Code.Ldloc_3: case Code.Ldloc_S: Ldloc.Emulate(ValueStack, instruction, _method); break; case Code.Ldloca: case Code.Ldloca_S: Ldloc.EmulateLdloca(ValueStack, instruction, _method); break; case Code.Ldnull: ValueStack.CallStack.Push(null); break; case Code.Ldobj: Ldobj.Emulate(ValueStack, instruction); break; case Code.Ldsfld: Ldsfld.Emulate(ValueStack, instruction); break; case Code.Ldsflda: throw new NotSupportedException(); case Code.Ldstr: ValueStack.CallStack.Push(instruction.Operand.ToString()); break; case Code.Ldtoken: Ldtoken.Emulate(ValueStack, instruction); break; case Code.Ldvirtftn: throw new NotSupportedException(); case Code.Leave: case Code.Leave_S: return(LEave.Emulate(ValueStack, instruction, _instructionsToEmulate)); case Code.Localloc: Localloc.Emulate(ValueStack); break; case Code.Mkrefany: throw new NotSupportedException(); case Code.Mul: case Code.Mul_Ovf: case Code.Mul_Ovf_Un: Mul.Emulate(ValueStack); break; case Code.Neg: ValueStack.CallStack.Push(-ValueStack.CallStack.Pop()); break; case Code.Newarr: NewArr.Emulate(ValueStack, instruction); break; case Code.Newobj: throw new NotSupportedException(); case Code.Nop: break; case Code.Not: Not.Emulate(ValueStack); break; case Code.Or: Or.Emulate(ValueStack); break; case Code.Pop: ValueStack.CallStack.Pop(); break; case Code.Prefix1: throw new NotSupportedException(); case Code.Prefix2: throw new NotSupportedException(); case Code.Prefix3: throw new NotSupportedException(); case Code.Prefix4: throw new NotSupportedException(); case Code.Prefix5: throw new NotSupportedException(); case Code.Prefix6: throw new NotSupportedException(); case Code.Prefix7: throw new NotSupportedException(); case Code.Prefixref: throw new NotSupportedException(); case Code.Readonly: throw new NotSupportedException(); case Code.Refanytype: throw new NotSupportedException(); case Code.Refanyval: throw new NotSupportedException(); case Code.Rem: Rem.Emulate(ValueStack); break; case Code.Rem_Un: Rem.Emulate_Un(ValueStack); break; case Code.Ret: break; case Code.Rethrow: throw new NotSupportedException(); case Code.Shl: Shl.Emulate(ValueStack); break; case Code.Shr: Shr.Emulate(ValueStack); break; case Code.Shr_Un: Shr.Emulate_Un(ValueStack); break; case Code.Sizeof: throw new NotSupportedException(); case Code.Starg: case Code.Starg_S: Starg.Emulate(ValueStack, instruction, _method); break; case Code.Stelem: throw new NotSupportedException(); case Code.Stelem_I: throw new NotSupportedException(); case Code.Stelem_I1: StelemI1.Emulate(ValueStack); break; case Code.Stelem_I2: break; case Code.Stelem_I4: Stelem_I4.Emulate(ValueStack); break; case Code.Stelem_I8: throw new NotSupportedException(); case Code.Stelem_R4: throw new NotSupportedException(); case Code.Stelem_R8: throw new NotSupportedException(); case Code.Stelem_Ref: Stelem_Ref.Emulate(ValueStack, instruction); break; case Code.Stfld: throw new NotSupportedException(); case Code.Stind_I: throw new NotSupportedException(); case Code.Stind_I1: StindI1.Emulate(ValueStack); break; case Code.Stind_I2: throw new NotSupportedException(); case Code.Stind_I4: StindI4.Emulate(ValueStack); break; case Code.Stind_I8: throw new NotSupportedException(); case Code.Stind_R4: throw new NotSupportedException(); case Code.Stind_R8: throw new NotSupportedException(); case Code.Stind_Ref: throw new NotSupportedException(); case Code.Stloc: case Code.Stloc_0: case Code.Stloc_1: case Code.Stloc_2: case Code.Stloc_3: case Code.Stloc_S: Stloc.Emulate(ValueStack, instruction, _method); break; case Code.Stobj: Stobj.Emulate(ValueStack, instruction); break; case Code.Stsfld: Stsfld.Emulate(ValueStack, instruction); break; case Code.Sub: Sub.Emulate(ValueStack); break; case Code.Sub_Ovf: case Code.Sub_Ovf_Un: Sub.Emulate_Ovf(ValueStack); break; case Code.Switch: return(Switch.Emulate(ValueStack, instruction, _instructionsToEmulate)); case Code.Tailcall: throw new NotSupportedException(); case Code.Throw: throw new NotSupportedException(); case Code.Unaligned: throw new NotSupportedException(); case Code.Unbox: throw new NotSupportedException(); case Code.Unbox_Any: // Box.Emulate_UnBox_Any(ValueStack,instruction); break; case Code.Volatile: throw new NotSupportedException(); case Code.Xor: Xor.Emulate(ValueStack); break; default: throw new ArgumentOutOfRangeException(); } return(i); }
ILInstruction MakeDynamicInstruction(CallSiteInfo callsite, CallVirt targetInvokeCall, List <ILInstruction> deadArguments) { switch (callsite.Kind) { case BinderMethodKind.BinaryOperation: deadArguments.AddRange(targetInvokeCall.Arguments.Take(2)); return(new DynamicBinaryOperatorInstruction( binderFlags: callsite.Flags, operation: callsite.Operation, context: callsite.Context, leftArgumentInfo: callsite.ArgumentInfos[0], left: targetInvokeCall.Arguments[2], rightArgumentInfo: callsite.ArgumentInfos[1], right: targetInvokeCall.Arguments[3] )); case BinderMethodKind.Convert: deadArguments.AddRange(targetInvokeCall.Arguments.Take(2)); ILInstruction result = new DynamicConvertInstruction( binderFlags: callsite.Flags, context: callsite.Context, type: callsite.ConvertTargetType, argument: targetInvokeCall.Arguments[2] ); if (result.ResultType == StackType.Unknown) { // if references are missing, we need to coerce the primitive type to None. // Otherwise we will get loads of assertions. result = new Conv(result, PrimitiveType.None, ((DynamicConvertInstruction)result).IsChecked, Sign.None); } return(result); case BinderMethodKind.GetIndex: deadArguments.AddRange(targetInvokeCall.Arguments.Take(2)); return(new DynamicGetIndexInstruction( binderFlags: callsite.Flags, context: callsite.Context, argumentInfo: callsite.ArgumentInfos, arguments: targetInvokeCall.Arguments.Skip(2).ToArray() )); case BinderMethodKind.GetMember: deadArguments.AddRange(targetInvokeCall.Arguments.Take(2)); return(new DynamicGetMemberInstruction( binderFlags: callsite.Flags, name: callsite.MemberName, context: callsite.Context, targetArgumentInfo: callsite.ArgumentInfos[0], target: targetInvokeCall.Arguments[2] )); case BinderMethodKind.Invoke: deadArguments.AddRange(targetInvokeCall.Arguments.Take(2)); return(new DynamicInvokeInstruction( binderFlags: callsite.Flags, context: callsite.Context, argumentInfo: callsite.ArgumentInfos, arguments: targetInvokeCall.Arguments.Skip(2).ToArray() )); case BinderMethodKind.InvokeConstructor: deadArguments.AddRange(targetInvokeCall.Arguments.Take(2)); return(new DynamicInvokeConstructorInstruction( binderFlags: callsite.Flags, context: callsite.Context, argumentInfo: callsite.ArgumentInfos, arguments: targetInvokeCall.Arguments.Skip(2).ToArray() )); case BinderMethodKind.InvokeMember: deadArguments.AddRange(targetInvokeCall.Arguments.Take(2)); return(new DynamicInvokeMemberInstruction( binderFlags: callsite.Flags, name: callsite.MemberName, typeArguments: callsite.TypeArguments, context: callsite.Context, argumentInfo: callsite.ArgumentInfos, arguments: targetInvokeCall.Arguments.Skip(2).ToArray() )); case BinderMethodKind.IsEvent: deadArguments.AddRange(targetInvokeCall.Arguments.Take(2)); return(new DynamicIsEventInstruction( binderFlags: callsite.Flags, name: callsite.MemberName, context: callsite.Context, argument: targetInvokeCall.Arguments[2] )); case BinderMethodKind.SetIndex: deadArguments.AddRange(targetInvokeCall.Arguments.Take(2)); return(new DynamicSetIndexInstruction( binderFlags: callsite.Flags, context: callsite.Context, argumentInfo: callsite.ArgumentInfos, arguments: targetInvokeCall.Arguments.Skip(2).ToArray() )); case BinderMethodKind.SetMember: deadArguments.AddRange(targetInvokeCall.Arguments.Take(2)); return(new DynamicSetMemberInstruction( binderFlags: callsite.Flags, name: callsite.MemberName, context: callsite.Context, targetArgumentInfo: callsite.ArgumentInfos[0], target: targetInvokeCall.Arguments[2], valueArgumentInfo: callsite.ArgumentInfos[1], value: targetInvokeCall.Arguments[3] )); case BinderMethodKind.UnaryOperation: deadArguments.AddRange(targetInvokeCall.Arguments.Take(2)); return(new DynamicUnaryOperatorInstruction( binderFlags: callsite.Flags, operation: callsite.Operation, context: callsite.Context, operandArgumentInfo: callsite.ArgumentInfos[0], operand: targetInvokeCall.Arguments[2] )); default: throw new ArgumentOutOfRangeException($"Value {callsite.Kind} is not supported!"); } }
ILInstruction MakeDynamicInstruction(CallSiteInfo callsite, CallVirt targetInvokeCall, List <ILInstruction> deadArguments) { switch (callsite.Kind) { case BinderMethodKind.BinaryOperation: deadArguments.AddRange(targetInvokeCall.Arguments.Take(2)); return(new DynamicBinaryOperatorInstruction( binderFlags: callsite.Flags, operation: callsite.Operation, context: callsite.Context, leftArgumentInfo: callsite.ArgumentInfos[0], left: targetInvokeCall.Arguments[2], rightArgumentInfo: callsite.ArgumentInfos[1], right: targetInvokeCall.Arguments[3] )); case BinderMethodKind.Convert: deadArguments.AddRange(targetInvokeCall.Arguments.Take(2)); ILInstruction result = new DynamicConvertInstruction( binderFlags: callsite.Flags, context: callsite.Context, type: callsite.ConvertTargetType, argument: targetInvokeCall.Arguments[2] ); if (result.ResultType == StackType.Unknown) { // if references are missing, we need to coerce the primitive type to None. // Otherwise we will get loads of assertions. result = new Conv(result, PrimitiveType.None, ((DynamicConvertInstruction)result).IsChecked, Sign.None); } return(result); case BinderMethodKind.GetIndex: deadArguments.AddRange(targetInvokeCall.Arguments.Take(2)); return(new DynamicGetIndexInstruction( binderFlags: callsite.Flags, context: callsite.Context, argumentInfo: callsite.ArgumentInfos, arguments: targetInvokeCall.Arguments.Skip(2).ToArray() )); case BinderMethodKind.GetMember: deadArguments.AddRange(targetInvokeCall.Arguments.Take(2)); return(new DynamicGetMemberInstruction( binderFlags: callsite.Flags, name: callsite.MemberName, context: callsite.Context, targetArgumentInfo: callsite.ArgumentInfos[0], target: targetInvokeCall.Arguments[2] )); case BinderMethodKind.Invoke: deadArguments.AddRange(targetInvokeCall.Arguments.Take(2)); return(new DynamicInvokeInstruction( binderFlags: callsite.Flags, context: callsite.Context, argumentInfo: callsite.ArgumentInfos, arguments: targetInvokeCall.Arguments.Skip(2).ToArray() )); case BinderMethodKind.InvokeConstructor: var arguments = targetInvokeCall.Arguments.Skip(2).ToArray(); // Extract type information from targetInvokeCall: // Must either be an inlined type or // a reference to a variable that is initialized with a type. if (!TransformExpressionTrees.MatchGetTypeFromHandle(arguments[0], out var type)) { if (!(arguments[0].MatchLdLoc(out var temp) && temp.IsSingleDefinition && temp.StoreInstructions.FirstOrDefault() is StLoc initStore)) { return(null); } if (!TransformExpressionTrees.MatchGetTypeFromHandle(initStore.Value, out type)) { return(null); } } deadArguments.AddRange(targetInvokeCall.Arguments.Take(2)); return(new DynamicInvokeConstructorInstruction( binderFlags: callsite.Flags, type: type ?? SpecialType.UnknownType, context: callsite.Context, argumentInfo: callsite.ArgumentInfos, arguments: arguments )); case BinderMethodKind.InvokeMember: deadArguments.AddRange(targetInvokeCall.Arguments.Take(2)); return(new DynamicInvokeMemberInstruction( binderFlags: callsite.Flags, name: callsite.MemberName, typeArguments: callsite.TypeArguments, context: callsite.Context, argumentInfo: callsite.ArgumentInfos, arguments: targetInvokeCall.Arguments.Skip(2).ToArray() )); case BinderMethodKind.IsEvent: deadArguments.AddRange(targetInvokeCall.Arguments.Take(2)); return(new DynamicIsEventInstruction( binderFlags: callsite.Flags, name: callsite.MemberName, context: callsite.Context, argument: targetInvokeCall.Arguments[2] )); case BinderMethodKind.SetIndex: deadArguments.AddRange(targetInvokeCall.Arguments.Take(2)); return(new DynamicSetIndexInstruction( binderFlags: callsite.Flags, context: callsite.Context, argumentInfo: callsite.ArgumentInfos, arguments: targetInvokeCall.Arguments.Skip(2).ToArray() )); case BinderMethodKind.SetMember: deadArguments.AddRange(targetInvokeCall.Arguments.Take(2)); return(new DynamicSetMemberInstruction( binderFlags: callsite.Flags, name: callsite.MemberName, context: callsite.Context, targetArgumentInfo: callsite.ArgumentInfos[0], target: targetInvokeCall.Arguments[2], valueArgumentInfo: callsite.ArgumentInfos[1], value: targetInvokeCall.Arguments[3] )); case BinderMethodKind.UnaryOperation: deadArguments.AddRange(targetInvokeCall.Arguments.Take(2)); return(new DynamicUnaryOperatorInstruction( binderFlags: callsite.Flags, operation: callsite.Operation, context: callsite.Context, operandArgumentInfo: callsite.ArgumentInfos[0], operand: targetInvokeCall.Arguments[2] )); default: throw new ArgumentOutOfRangeException($"Value {callsite.Kind} is not supported!"); } }