/// <inheritdoc /> public void WriteFloat64(int offset, Float64Value value) { if (IsKnown) { BasePointer.WriteFloat64(CurrentOffset + offset, value); } }
/// <inheritdoc /> public void WriteFloat64(int offset, Float64Value value) { if (IsKnown) { ReferencedMemory.WriteFloat64(CurrentOffset + offset, value); } }
public void ReadWriteFloat64() { var ptrValue = new MemoryBlockValue(8); var value = new Float64Value(0.12345678d); ptrValue.WriteFloat64(0, value); Assert.Equal(value.F64, ptrValue.ReadFloat64(0).F64); }
/// <inheritdoc /> public unsafe void WriteFloat64(int offset, Float64Value value) { AssertOffsetValidity(offset, sizeof(double)); // Note: There is unfortunately no BinaryPrimitives method for writing single or double values in // .NET Standard 2.0. Hence we go the unsafe route. using var handle = _memory.Pin(); *(double *)((byte *)handle.Pointer + offset) = value.F64; _knownBitMask.Span.Slice(offset, 8).Fill(0xFF); }
public void ReadWriteFloat64() { using var memoryOwner = MemoryPool <byte> .Shared.Rent(8); using var bitmaskOwner = MemoryPool <byte> .Shared.Rent(8); var ptrValue = new MemoryPointerValue(memoryOwner.Memory, bitmaskOwner.Memory, true); var value = new Float64Value(0.12345678d); ptrValue.WriteFloat64(0, value); Assert.Equal(value.F64, ptrValue.ReadFloat64(0).F64); }
public void PersistentBits() { const double testValue = 0.123D; var value = new Float64Value(testValue); Span <byte> buffer = stackalloc byte[sizeof(double)]; Span <byte> mask = stackalloc byte[sizeof(double)]; value.GetBits(buffer); value.GetMask(mask); value.SetBits(buffer, mask); Assert.Equal(testValue, value.F64); }
/// <inheritdoc /> protected override DispatchResult Execute(ExecutionContext context, Float64Value value) => DispatchResult.InvalidProgram();
/// <inheritdoc /> public void WriteFloat64(int offset, Float64Value value) => Contents.WriteFloat64(offset, value);
/// <inheritdoc /> protected override DispatchResult Execute(ExecutionContext context, Float64Value value) { value.F64 = -value.F64; context.ProgramState.Stack.Push(value); return(DispatchResult.Success()); }
public override void Execute(Context context, IEnumerable <MetadataMember> targets) { if (!context.IsReflectionCorlibSafe) { return; } foreach (var Method in targets.OfType <MethodDefinition>().Where(m => m.CilMethodBody is not null)) { var Instructions = Method.CilMethodBody.Instructions; Method.CilMethodBody.ConstructSymbolicFlowGraph(out var DFG); /* Dfg Constructing. */ for (int x = 0; x < Instructions.Count; x++) { var Instr = Instructions[x]; /* Some People Make It Callvirt To Deafet Public tools :p */ if ((Instr.IsCode(CilCode.Call) || Instr.IsCode(CilCode.Callvirt)) && Instr.IsFromNS("System", "Math") && DFG.Nodes.Contains(Instr.Offset)) { var CallNode = DFG.Nodes[Instr.Offset] .GetOrderedDependencies(DependencyCollectionFlags.IncludeStackDependencies) .ToList(); if (CallNode.Any(x => x.Contents.OpCode.OperandType == CilOperandType.InlineMethod)) { continue; } var vm = new CilVirtualMachine(Method.CilMethodBody, context.Module.Is32Module()); var ex = new CilExecutionContext(vm, vm.CurrentState, default); foreach (var Dep in CallNode) { var CInstr = Dep.Contents; vm.Dispatcher.Execute(ex, CInstr); CInstr.Nop(); } var ISlot = new object[((IMethodDescriptor)Instr.Operand) .Signature.GetTotalParameterCount()]; for (int i = 0; i < ISlot.Length; i++) { var Value = vm.CurrentState.Stack.Pop(); ISlot[i] = Value switch { I4Value I4 => I4.I32, I8Value I8 => I8.I64, FValue F => F.F64, Float32Value F32 => F32.F32, Float64Value F64 => F64.F64, Integer16Value I6 => I6.I16, Integer32Value I32 => I32.I32, Integer64Value I64 => I64.I64, _ => throw new NotSupportedException(nameof(Value)) }; } var InvocationValue = context.ReflectionCorlib.ResolveMethod(((IMethodDescriptor)Instr.Operand).MetadataToken.ToInt32()) .Invoke(null, ISlot); Instr.OpCode = ((IMethodDescriptor)Instr.Operand).Signature.ReturnType.ElementType switch { ElementType.I4 => CilOpCodes.Ldc_I4, ElementType.I8 => CilOpCodes.Ldc_I8, ElementType.R4 => CilOpCodes.Ldc_R4, ElementType.R8 => CilOpCodes.Ldc_R8, _ => CilOpCodes.Ldc_I4, }; Instr.Operand = InvocationValue; } } } } }
/// <summary> /// Performs the operation on the pushed floating point value. /// </summary> /// <param name="context">The context to execute the instruction in.</param> /// <param name="value">The pushed value to perform the operation on.</param> /// <returns>The result of the operation.</returns> protected abstract DispatchResult Execute(ExecutionContext context, Float64Value value);