public static DebugInterfaceDeclarationToken Parse(DebugBytecodeReader reader) { uint token0 = reader.ReadUInt32("token0"); DebugOpcodeHeader.AddNotes(reader, token0); reader.AddNote("DynamicallyIndex", token0.DecodeValue(11, 11) == 1); var result = new DebugInterfaceDeclarationToken { DynamicallyIndexed = (token0.DecodeValue(11, 11) == 1), Identifier = reader.ReadUInt32("Identifier"), ExpectedFunctionTableLength = reader.ReadUInt32("ExpectedFunctionTableLength") }; uint token3 = reader.ReadUInt32("token3"); result.TableLength = token3.DecodeValue <ushort>(00, 15); result.ArrayLength = token3.DecodeValue <ushort>(16, 31); reader.AddNote("TableLength", result.TableLength); reader.AddNote("ArrayLength", result.ArrayLength); for (int i = 0; i < result.TableLength; i++) { result.FunctionTableIdentifiers.Add(reader.ReadUInt32($"FunctionTableIdentifiers[{i}]")); } return(result); }
public static DebugFxlcToken Parse(DebugBytecodeReader reader) { var result = new DebugFxlcToken(); var token = reader.ReadUInt32($"Token"); var tokenComponentCount = token.DecodeValue(0, 2); result.Type = (FxlcOpcode)token.DecodeValue(20, 30); result.IsScalarInstruction = token.DecodeValue <bool>(31, 31); Debug.Assert(Enum.IsDefined(typeof(FxlcOpcode), result.Type), $"Unknown FxlcTokenType {result.Type}"); Debug.Assert(token.DecodeValue(3, 19) == 0, $"Unexpected data in FxlcToken bits 3-19 {token.DecodeValue(3, 19)}"); reader.AddNote("Token", result.Type); reader.AddNote("TokenComponentCount", tokenComponentCount); reader.AddNote("IsScalarInstruction", result.IsScalarInstruction); var operandCount = result.OperandCount = reader.ReadUInt32("OperandCount"); for (int i = 0; i < operandCount; i++) { var isScalarOp = i == 0 && result.IsScalarInstruction; result.Operands.Add(DebugFxlcOperand.Parse(reader, tokenComponentCount, isScalarOp)); } // destination operand result.Operands.Insert(0, DebugFxlcOperand.Parse(reader, tokenComponentCount, false)); return(result); }
public static void AddNotes(DebugBytecodeReader reader, uint opcodeToken0) { var opcodeType = opcodeToken0.DecodeValue <OpcodeType>(0, 10); var length = opcodeToken0.DecodeValue(24, 30); var isExtended = (opcodeToken0.DecodeValue(31, 31) == 1); reader.AddNote("OpcodeType", opcodeType); reader.AddNote("Length", length); reader.AddNote("IsExtended", isExtended); }
bool ReadCommentToken(DebugBytecodeReader reader) { var fourCC = reader.PeakUInt32Ahead(4); if (KnownCommentTypes.ContainsKey(fourCC)) { reader.AddIndent(KnownCommentTypes[fourCC].ToString()); } else { return(false); } var instructionToken = reader.ReadUInt32("Token"); var startPosition = reader._reader.BaseStream.Position; Opcode opcode = (Opcode)(instructionToken & 0xffff); reader.AddNote("TokenOpcode", opcode); var size = (int)((instructionToken >> 16) & 0x7FFF); reader.AddNote("TokenSize", size); reader.ReadBytes("FourCC", 4); switch (KnownCommentTypes[fourCC]) { case CommentType.CTAB: ConstantTable = DebugConstantTable.Parse(reader); break; case CommentType.C**T: Cli = DebugCliToken.Parse(reader); break; case CommentType.FXLC: Fxlc = DebugFxlc.Parse(reader, (uint)size * 4); break; case CommentType.PRES: Preshader = DebugPreshader.Parse(reader); break; case CommentType.PRSI: Prsi = DebugPrsiToken.Parse(reader, (uint)size); break; default: return(false); } reader.RemoveIndent(); reader._reader.BaseStream.Position = startPosition + size * 4; return(true); }
public static SystemValueName Parse(DebugBytecodeReader reader) { uint token = reader.ReadUInt32("token"); reader.AddNote("SystemValueName", token.DecodeValue <SystemValueName>(0, 15)); return(token.DecodeValue <SystemValueName>(0, 15)); }
public static DebugResourceReturnTypeToken Parse(DebugBytecodeReader reader) { var token = reader.ReadUInt32("token"); var result = new DebugResourceReturnTypeToken { X = token.DecodeValue <ResourceReturnType>(00, 03), Y = token.DecodeValue <ResourceReturnType>(04, 07), Z = token.DecodeValue <ResourceReturnType>(08, 11), W = token.DecodeValue <ResourceReturnType>(12, 15) }; reader.AddNote("X", result.X); reader.AddNote("Y", result.Y); reader.AddNote("Z", result.Z); reader.AddNote("W", result.W); return(result); }
public static DebugTessellatorOutputPrimitiveDeclarationToken Parse(DebugBytecodeReader reader) { var token0 = reader.ReadUInt32("token0"); DebugOpcodeHeader.AddNotes(reader, token0); reader.AddNote("OutputPrimitive", token0.DecodeValue <TessellatorOutputPrimitive>(11, 13)); return(new DebugTessellatorOutputPrimitiveDeclarationToken { OutputPrimitive = token0.DecodeValue <TessellatorOutputPrimitive>(11, 13) }); }
public static DebugGeometryShaderOutputPrimitiveTopologyDeclarationToken Parse(DebugBytecodeReader reader) { var token0 = reader.ReadUInt32("token0"); DebugOpcodeHeader.AddNotes(reader, token0); reader.AddNote("PriomitiveTopology", token0.DecodeValue <PrimitiveTopology>(11, 17)); return(new DebugGeometryShaderOutputPrimitiveTopologyDeclarationToken { PrimitiveTopology = token0.DecodeValue <PrimitiveTopology>(11, 17) }); }
public static DebugTessellatorPartitioningDeclarationToken Parse(DebugBytecodeReader reader) { var token0 = reader.ReadUInt32("token0"); DebugOpcodeHeader.AddNotes(reader, token0); reader.AddNote("Partitioning", token0.DecodeValue <TessellatorPartitioning>(11, 13)); return(new DebugTessellatorPartitioningDeclarationToken { Partitioning = token0.DecodeValue <TessellatorPartitioning>(11, 13) }); }
public static DebugStreamDeclarationToken Parse(DebugBytecodeReader reader) { var token0 = reader.ReadUInt32("token0"); DebugOpcodeHeader.AddNotes(reader, token0); reader.AddNote("OpcodeType", token0.DecodeValue <OpcodeType>(0, 10)); return(new DebugStreamDeclarationToken { Operand = DebugOperand.Parse(reader, token0.DecodeValue <OpcodeType>(0, 10)) }); }
public static DebugGlobalFlagsDeclarationToken Parse(DebugBytecodeReader reader) { var token0 = reader.ReadUInt32("token0"); DebugOpcodeHeader.AddNotes(reader, token0); var result = new DebugGlobalFlagsDeclarationToken(); result.Flags = token0.DecodeValue <GlobalFlags>(11, 18); reader.AddNote("Flags", result.Flags); return(result); }
public static DebugDestinationOperand Parse(DebugBytecodeReader reader, uint index) { var token = reader.ReadUInt32($"Operand {index}"); var result = new DebugDestinationOperand(); result.WordCount = 1; result.RegisterNumber = token & 0x7FF; result.RegisterType = (RegisterType)(((token >> 28) & 0x7) | ((token >> 8) & 0x18)); result.MinPrecision = (token >> 12) & 0XC; result.DestinationWriteMask = (ComponentFlags)((token >> 16) & 0xF); result.ResultModifier = (ResultModifier)((token >> 20) & 0xF); reader.AddNote("RegisterNumber", result.RegisterNumber); reader.AddNote("RegisterType", result.RegisterType); reader.AddNote("MinPrecision", result.MinPrecision); reader.AddNote("DestinationWriteMask", result.DestinationWriteMask); reader.AddNote("ResultModifier", result.ResultModifier); return(result); }
public static DebugGeometryShaderInputPrimitiveDeclarationToken Parse(DebugBytecodeReader reader) { var token0 = reader.ReadUInt32("token0"); DebugOpcodeHeader.AddNotes(reader, token0); reader.AddNote("Primitive", token0.DecodeValue <Primitive>(11, 16)); return(new DebugGeometryShaderInputPrimitiveDeclarationToken { Primitive = token0.DecodeValue <Primitive>(11, 16) }); }
public static DebugTessellatorDomainDeclarationToken Parse(DebugBytecodeReader reader) { var token0 = reader.ReadUInt32("token0"); DebugOpcodeHeader.AddNotes(reader, token0); reader.AddNote("Domain", token0.DecodeValue <TessellatorDomain>(11, 12)); return(new DebugTessellatorDomainDeclarationToken { Domain = token0.DecodeValue <TessellatorDomain>(11, 12) }); }
private static void ReadExtendedOperand(DebugOperand operand, DebugBytecodeReader reader) { uint token1 = reader.ReadUInt32("token1"); var type = token1.DecodeValue <ExtendedOperandType>(0, 5); reader.AddNote("type", type); switch (type) { case ExtendedOperandType.Modifier: operand.Modifier = token1.DecodeValue <OperandModifier>(6, 13); operand.MinPrecision = token1.DecodeValue <OperandMinPrecision>(14, 16); operand.NonUniform = token1.DecodeValue <bool>(17, 17); reader.AddNote("Modifier", operand.Modifier); reader.AddNote("MinPrecision", operand.MinPrecision); reader.AddNote("NonUniform", operand.NonUniform); break; default: throw new Exception($"Unknown Extended modifier {type}"); } }
public static DebugResourceDeclarationToken Parse(DebugBytecodeReader reader, DebugShaderVersion version) { var token0 = reader.ReadUInt32("token0"); DebugOpcodeHeader.AddNotes(reader, token0); var resourceDimension = token0.DecodeValue <ResourceDimension>(11, 15); reader.AddNote("resourceDimension", resourceDimension); byte sampleCount; switch (resourceDimension) { case ResourceDimension.Texture2DMultiSampled: case ResourceDimension.Texture2DMultiSampledArray: sampleCount = token0.DecodeValue <byte>(16, 22); reader.AddNote("SampleCount", sampleCount); break; default: sampleCount = 0; break; } var operand = DebugOperand.Parse(reader, token0.DecodeValue <OpcodeType>(0, 10)); var returnType = DebugResourceReturnTypeToken.Parse(reader); var result = new DebugResourceDeclarationToken { ResourceDimension = resourceDimension, SampleCount = sampleCount, Operand = operand, ReturnType = returnType }; if (version.IsSM51) { result.SpaceIndex = reader.ReadUInt32("SpaceIndex"); } return(result); }
public static DebugRawUnorderedAccessViewDeclarationToken Parse(DebugBytecodeReader reader, DebugShaderVersion version) { var token0 = reader.ReadUInt32("token0"); DebugOpcodeHeader.AddNotes(reader, token0); reader.AddNote("Coherency", token0.DecodeValue <UnorderedAccessViewCoherency>(16, 16)); reader.AddNote("IsRasterOrderedAccess", token0.DecodeValue <bool>(17, 17)); reader.AddNote("OpcodeType", token0.DecodeValue <OpcodeType>(0, 10)); var result = new DebugRawUnorderedAccessViewDeclarationToken { Coherency = token0.DecodeValue <UnorderedAccessViewCoherency>(16, 16), IsRasterOrderedAccess = token0.DecodeValue <bool>(17, 17), Operand = DebugOperand.Parse(reader, token0.DecodeValue <OpcodeType>(0, 10)) }; if (version.IsSM51) { result.SpaceIndex = reader.ReadUInt32("SpaceIndex"); } return(result); }
public static DebugRawThreadGroupSharedMemoryDeclarationToken Parse(DebugBytecodeReader reader) { var token0 = reader.ReadUInt32("token0"); DebugOpcodeHeader.AddNotes(reader, token0); reader.AddNote("OpcodeType", token0.DecodeValue <OpcodeType>(0, 10)); var result = new DebugRawThreadGroupSharedMemoryDeclarationToken { Operand = DebugOperand.Parse(reader, token0.DecodeValue <OpcodeType>(0, 10)), ElementCount = reader.ReadUInt32("ElementCount") }; return(result); }
public static DebugInputRegisterDeclarationToken Parse(DebugBytecodeReader reader) { uint token0 = reader.ReadUInt32("token0"); var opcodeType = token0.DecodeValue <OpcodeType>(0, 10); DebugOpcodeHeader.AddNotes(reader, token0); DebugInputRegisterDeclarationToken result; switch (opcodeType) { case OpcodeType.DclInput: case OpcodeType.DclInputSgv: case OpcodeType.DclInputSiv: result = new DebugInputRegisterDeclarationToken(); break; case OpcodeType.DclInputPs: case OpcodeType.DclInputPsSgv: case OpcodeType.DclInputPsSiv: result = new DebugPixelShaderInputRegisterDeclarationToken { InterpolationMode = token0.DecodeValue <InterpolationMode>(11, 14) }; reader.AddNote("InterpolationMode", token0.DecodeValue <InterpolationMode>(11, 14)); break; default: throw new ParseException("Unrecognised opcode type: " + opcodeType); } result.Operand = DebugOperand.Parse(reader, opcodeType); switch (opcodeType) { case OpcodeType.DclInputSgv: case OpcodeType.DclInputSiv: case OpcodeType.DclInputPsSgv: case OpcodeType.DclInputPsSiv: result.SystemValueName = DebugNameToken.Parse(reader); break; } return(result); }
public static DebugSamplerDeclarationToken Parse(DebugBytecodeReader reader, DebugShaderVersion version) { var token0 = reader.ReadUInt32("token0"); DebugOpcodeHeader.AddNotes(reader, token0); reader.AddNote("SamplerMode", token0.DecodeValue <SamplerMode>(11, 14)); var operand = DebugOperand.Parse(reader, token0.DecodeValue <OpcodeType>(0, 10)); var result = new DebugSamplerDeclarationToken { SamplerMode = token0.DecodeValue <SamplerMode>(11, 14), Operand = operand }; if (version.IsSM51) { result.SpaceIndex = reader.ReadUInt32("SpaceIndex"); } return(result); }
public static DebugConstantBufferDeclarationToken Parse(DebugBytecodeReader reader, DebugShaderVersion version) { var token0 = reader.ReadUInt32("Token0"); DebugOpcodeHeader.AddNotes(reader, token0); reader.AddNote("AccessPattern", token0.DecodeValue <ConstantBufferAccessPattern>(11, 11)); var result = new DebugConstantBufferDeclarationToken { AccessPattern = token0.DecodeValue <ConstantBufferAccessPattern>(11, 11), Operand = DebugOperand.Parse(reader, token0.DecodeValue <OpcodeType>(0, 10)) }; if (version.IsSM51) { result.m_ConstantBufferSize = reader.ReadUInt32("SM51_ConstantBufferSize"); result.SpaceIndex = reader.ReadUInt32("SpaceIndex"); } return(result); }
public static DebugSourceOperand Parse(DebugBytecodeReader reader, uint index) { var token = reader.ReadUInt32($"Operand {index}"); var result = new DebugSourceOperand(); result.WordCount = 1; result.RegisterNumber = (token & 0x7FF); result.RegisterType = (RegisterType)(((token >> 28) & 0x7) | ((token >> 8) & 0x18)); result.IsRelativeAddressMode = (token & (1 << 13)) != 0; result.MinPrecision = ((token >> 12) & 0XC); result.SwizzleComponents = ((token >> 16) & 0xFF); result.SourceModifier = (SourceModifier)((token >> 24) & 0xF); reader.AddNote("RegisterNumber", result.RegisterNumber); reader.AddNote("RegisterType", result.RegisterType); reader.AddNote("IsRelativeAddressMode", result.IsRelativeAddressMode); reader.AddNote("MinPrecision", result.MinPrecision); reader.AddNote("SwizzleComponents", result.SwizzleComponents); reader.AddNote("SourceModifier", result.SourceModifier); return(result); }
public static DebugInstructionToken Parse(DebugBytecodeReader reader, DebugOpcodeHeader header) { var instructionToken = new DebugInstructionToken(); // Advance to next token. var instructionEnd = reader.CurrentPosition + (header.Length * sizeof(uint)); var token0 = reader.ReadUInt32("token0"); DebugOpcodeHeader.AddNotes(reader, token0); if (header.OpcodeType == OpcodeType.Sync) { instructionToken.SyncFlags = token0.DecodeValue <SyncFlags>(11, 14); reader.AddNote("SyncFlags", instructionToken.SyncFlags); } else { instructionToken.ResInfoReturnType = token0.DecodeValue <ResInfoReturnType>(11, 12); instructionToken.Saturate = (token0.DecodeValue(13, 13) == 1); instructionToken.TestBoolean = token0.DecodeValue <InstructionTestBoolean>(18, 18); instructionToken.PreciseValueMask = token0.DecodeValue <ComponentMask>(19, 22); reader.AddNote("ResInfoReturnType", instructionToken.ResInfoReturnType); reader.AddNote("Saturate", instructionToken.Saturate); reader.AddNote("TestBoolean", instructionToken.TestBoolean); reader.AddNote("PreciseValueMask", instructionToken.PreciseValueMask); } bool extended = header.IsExtended; while (extended) { uint extendedToken = reader.ReadUInt32("extendedToken"); var extendedType = extendedToken.DecodeValue <InstructionTokenExtendedType>(0, 5); reader.AddNote("extendedType", extendedType); instructionToken.ExtendedTypes.Add(extendedType); extended = (extendedToken.DecodeValue(31, 31) == 1); reader.AddNote("extended", extended); switch (extendedType) { case InstructionTokenExtendedType.SampleControls: instructionToken.SampleOffsets[0] = extendedToken.DecodeSigned4BitValue(09, 12); instructionToken.SampleOffsets[1] = extendedToken.DecodeSigned4BitValue(13, 16); instructionToken.SampleOffsets[2] = extendedToken.DecodeSigned4BitValue(17, 20); reader.AddNote("SampleOffsets[0]", instructionToken.SampleOffsets[0]); reader.AddNote("SampleOffsets[1]", instructionToken.SampleOffsets[1]); reader.AddNote("SampleOffsets[2]", instructionToken.SampleOffsets[2]); break; case InstructionTokenExtendedType.ResourceDim: instructionToken.ResourceTarget = extendedToken.DecodeValue <ResourceDimension>(6, 10); instructionToken.ResourceStride = extendedToken.DecodeValue <ushort>(11, 22); reader.AddNote("ResourceTarget", instructionToken.ResourceTarget); reader.AddNote("ResourceStride", instructionToken.ResourceStride); break; case InstructionTokenExtendedType.ResourceReturnType: instructionToken.ResourceReturnTypes[0] = extendedToken.DecodeValue <ResourceReturnType>(06, 09); instructionToken.ResourceReturnTypes[1] = extendedToken.DecodeValue <ResourceReturnType>(10, 13); instructionToken.ResourceReturnTypes[2] = extendedToken.DecodeValue <ResourceReturnType>(14, 17); instructionToken.ResourceReturnTypes[3] = extendedToken.DecodeValue <ResourceReturnType>(18, 21); reader.AddNote("ResourceReturnTypes[0]", instructionToken.ResourceReturnTypes[0]); reader.AddNote("ResourceReturnTypes[1]", instructionToken.ResourceReturnTypes[1]); reader.AddNote("ResourceReturnTypes[2]", instructionToken.ResourceReturnTypes[2]); reader.AddNote("ResourceReturnTypes[3]", instructionToken.ResourceReturnTypes[3]); break; default: throw new ParseException("Unrecognised extended type: " + extendedType); } } if (header.OpcodeType == OpcodeType.InterfaceCall) { instructionToken.FunctionIndex = reader.ReadUInt32("FunctionIndex"); } while (reader.CurrentPosition < instructionEnd) { reader.AddIndent($"Operand{instructionToken.Operands.Count}"); var operand = DebugOperand.Parse(reader, header.OpcodeType); if (operand != null) { instructionToken.Operands.Add(operand); } reader.RemoveIndent(); } return(instructionToken); }
public static DebugOperand Parse(DebugBytecodeReader reader, OpcodeType parentType) { uint token0 = reader.ReadUInt32("operandToken"); if (token0 == 0) { return(null); } var member = reader.LocalMembers.Last(); var operand = new DebugOperand(parentType); var numComponents = token0.DecodeValue <OperandNumComponents>(0, 1); reader.AddNote("numComponents", numComponents); switch (numComponents) { case OperandNumComponents.Zero: { operand.NumComponents = 0; break; } case OperandNumComponents.One: { operand.NumComponents = 1; break; } case OperandNumComponents.Four: { operand.NumComponents = 4; operand.SelectionMode = token0.DecodeValue <Operand4ComponentSelectionMode>(2, 3); member.AddNote("SelectionMode", operand.SelectionMode); switch (operand.SelectionMode) { case Operand4ComponentSelectionMode.Mask: { operand.ComponentMask = token0.DecodeValue <ComponentMask>(4, 7); member.AddNote("ComponentMask", operand.ComponentMask); break; } case Operand4ComponentSelectionMode.Swizzle: { var swizzle = token0.DecodeValue(4, 11); Func <uint, byte, Operand4ComponentName> swizzleDecoder = (s, i) => (Operand4ComponentName)((s >> (i * 2)) & 3); operand.Swizzles[0] = swizzleDecoder(swizzle, 0); operand.Swizzles[1] = swizzleDecoder(swizzle, 1); operand.Swizzles[2] = swizzleDecoder(swizzle, 2); operand.Swizzles[3] = swizzleDecoder(swizzle, 3); member.AddNote("Swizzles[0]", operand.Swizzles[0]); member.AddNote("Swizzles[1]", operand.Swizzles[1]); member.AddNote("Swizzles[2]", operand.Swizzles[2]); member.AddNote("Swizzles[3]", operand.Swizzles[3]); break; } case Operand4ComponentSelectionMode.Select1: { var swizzle = token0.DecodeValue <Operand4ComponentName>(4, 5); operand.Swizzles[0] = operand.Swizzles[1] = operand.Swizzles[2] = operand.Swizzles[3] = swizzle; member.AddNote("Swizzles[0]", operand.Swizzles[0]); member.AddNote("Swizzles[1]", operand.Swizzles[1]); member.AddNote("Swizzles[2]", operand.Swizzles[2]); member.AddNote("Swizzles[3]", operand.Swizzles[3]); break; } default: { throw new ParseException("Unrecognized selection method: " + operand.SelectionMode); } } break; } case OperandNumComponents.N: { throw new ParseException("OperandNumComponents.N is not currently supported."); } } operand.OperandType = token0.DecodeValue <OperandType>(12, 19); member.AddNote("OperandType", operand.OperandType); operand.IndexDimension = token0.DecodeValue <OperandIndexDimension>(20, 21); member.AddNote("IndexDimension", operand.IndexDimension); operand.IsExtended = token0.DecodeValue(31, 31) == 1; member.AddNote("IsExtended", operand.IsExtended); if (operand.IsExtended) { ReadExtendedOperand(operand, reader); } Func <uint, byte, OperandIndexRepresentation> indexRepresentationDecoder = (t, i) => (OperandIndexRepresentation)t.DecodeValue((byte)(22 + (i * 3)), (byte)(22 + (i * 3) + 2)); for (byte i = 0; i < (byte)operand.IndexDimension; i++) { operand.Indices[i] = new DebugOperandIndex(); var indexRepresentation = indexRepresentationDecoder(token0, i); operand.Indices[i].Representation = indexRepresentation; member.AddNote($"Indices[{i}].Representation", operand.Indices[i].Representation); switch (indexRepresentation) { case OperandIndexRepresentation.Immediate32: operand.Indices[i].Value = reader.ReadUInt32($"Indices[{i}].Value"); break; case OperandIndexRepresentation.Immediate64: operand.Indices[i].Value = reader.ReadUInt64($"Indices[{i}].Value"); goto default; case OperandIndexRepresentation.Relative: operand.Indices[i].Register = Parse(reader, parentType); break; case OperandIndexRepresentation.Immediate32PlusRelative: operand.Indices[i].Value = reader.ReadUInt32($"Indices[{i}].Value"); goto case OperandIndexRepresentation.Relative; case OperandIndexRepresentation.Immediate64PlusRelative: operand.Indices[i].Value = reader.ReadUInt64($"Indices[{i}].Value"); goto case OperandIndexRepresentation.Relative; default: throw new ParseException("Unrecognised index representation: " + indexRepresentation); } } var numberType = parentType.GetNumberType(); switch (operand.OperandType) { case OperandType.Immediate32: { var immediateValues = new DebugNumber4(); for (var i = 0; i < operand.NumComponents; i++) { immediateValues.SetNumber(i, DebugNumber.Parse(reader)); } operand.ImmediateValues = immediateValues; break; } case OperandType.Immediate64: { var immediateValues = new DebugNumber4(); for (var i = 0; i < operand.NumComponents; i++) { immediateValues.SetDouble(i, reader.ReadDouble($"ImmediateValues[{i}]")); } operand.ImmediateValues = immediateValues; break; } } return(operand); }