internal void UpdateVersion(DebugShaderVersion version) { if (Reader == null) { return; } Reader.ReadUInt32("Unknown"); switch (version.ProgramType) { case ProgramType.VertexShader: Info = DebugVSInfo.Parse(Reader); break; case ProgramType.HullShader: Info = DebugHSInfo.Parse(Reader); break; case ProgramType.DomainShader: Info = DebugDSInfo.Parse(Reader); break; case ProgramType.GeometryShader: Info = DebugGSInfo.Parse(Reader); break; case ProgramType.PixelShader: Info = DebugPSInfo.Parse(Reader); break; default: Reader.ReadBytes("Unknown", 32); break; } if (Info != null && Info.StructSize < DebugValidationInfo.UnionSize) { Reader.ReadBytes("Padding", DebugValidationInfo.UnionSize - Info.StructSize); } MinimumExpectedWaveLaneCount = Reader.ReadUInt32("MinimumExpectedWaveLaneCount"); MaximumExpectedWaveLaneCount = Reader.ReadUInt32("MaximumExpectedWaveLaneCount"); if (ChunkSize > 20) { Reader.ReadEnum8 <PSVShaderKind>("ShaderStage"); UsesViewID = Reader.ReadByte("UsesViewID"); GSMaxVertexCount = Reader.ReadByte("MaxVertexCount"); SigInputElements = Reader.ReadByte("SigInputElements"); SigOutputElements = Reader.ReadByte("SigOutputElements"); SigPatchConstOrPrimElements = Reader.ReadByte("SigPatchConstOrPrimElements"); SigInputVectors = Reader.ReadByte("SigInputVectors"); SigOutputVectors = Reader.ReadBytes("SigOutputVectors", 4); } Reader = null; }
public static DebugStateBlob Parse(DebugBytecodeReader reader, DebugBytecodeReader blobReader) { var result = new DebugStateBlob(); result.TechniqueIndex = blobReader.ReadUInt32("TechniqueIndex"); result.PassIndex = blobReader.ReadUInt32("PassIndex"); result.SamplerStateIndex = blobReader.ReadUInt32("SamplerStateIndex"); result.AssignmentIndex = blobReader.ReadUInt32("AssignmentIndex"); result.BlobType = blobReader.ReadEnum32 <StateBlobType>("BlobType"); if (result.BlobType == StateBlobType.Shader) { result.ShaderSize = blobReader.ReadUInt32("BlobSize"); var startPosition = blobReader._reader.BaseStream.Position; var shaderReader = blobReader.CopyAtCurrentPosition("ShaderReader", blobReader); result.Shader = DebugShaderModel.Parse(shaderReader); blobReader._reader.BaseStream.Position = startPosition + result.ShaderSize; } if (result.BlobType == StateBlobType.Variable) { result.VariableName = blobReader.TryReadString("VariableName"); } else if (result.BlobType == StateBlobType.IndexShader) { result.ShaderSize = blobReader.ReadUInt32("BlobSize"); var startPosition = blobReader._reader.BaseStream.Position; var variableSize = blobReader.ReadUInt32("VariableNameSize"); var variableData = blobReader.ReadBytes("VariableData", (int)variableSize); result.VariableName = Encoding.UTF8.GetString(variableData, 0, variableData.Length - 1); var shaderReader = blobReader.CopyAtCurrentPosition("ShaderReader", blobReader); result.Shader = DebugShaderModel.Parse(shaderReader); blobReader._reader.BaseStream.Position = startPosition + result.ShaderSize; } return(result); }
public static DebugShaderMessageDeclarationToken Parse(DebugBytecodeReader reader) { var token0 = reader.ReadUInt32("token0"); DebugOpcodeHeader.AddNotes(reader, token0); var member = reader.LocalMembers.Last(); var length = reader.ReadUInt32("length") - 2; var result = new DebugShaderMessageDeclarationToken { DeclarationLength = length, InfoQueueMessageID = reader.ReadUInt32("InfoQueueMessageID"), MessageFormat = reader.ReadEnum32 <ShaderMessageFormat>("MessageFormat"), NumCharacters = reader.ReadUInt32("NumCharacters"), NumOperands = reader.ReadUInt32("NumOperands"), OperandsLength = reader.ReadUInt32("OperandsLength") }; for (int i = 0; i < result.NumOperands; i++) { result.Operands.Add(DebugOperand.Parse(reader, OpcodeType.CustomData)); } result.Format = reader.ReadString("Format"); // String is padded to a multiple of DWORDs. uint remainingBytes = (4 - ((result.NumCharacters + 1) % 4)) % 4; reader.ReadBytes("StringPadding", (int)remainingBytes); return(result); }
public static DebugHashChunk Parse(DebugBytecodeReader reader, uint chunkSize) { var result = new DebugHashChunk(); result.Flags = reader.ReadUInt32("Flags"); result.Digest = reader.ReadBytes("Digest", DigestSize); return(result); }
public static DebugShaderProgramChunk Parse(DebugBytecodeReader reader) { var program = new DebugShaderProgramChunk { Version = DebugShaderVersion.ParseShex(reader), Length = reader.ReadUInt32("Length") }; while (!reader.EndOfBuffer) { var opcodeIndex = program.Tokens.Count; var opcodeToken0 = reader.PeakUint32(); var opcodeHeader = new DebugOpcodeHeader { OpcodeType = opcodeToken0.DecodeValue <OpcodeType>(0, 10), Length = opcodeToken0.DecodeValue(24, 30), IsExtended = (opcodeToken0.DecodeValue(31, 31) == 1) }; DebugOpcodeToken opcodeToken = null; if (opcodeHeader.Length == 0 && opcodeHeader.OpcodeType != OpcodeType.CustomData) { throw new Exception("Error parsing shader"); } if (opcodeHeader.OpcodeType == OpcodeType.CustomData) { //opcodeToken = DebugCustomDataToken.Parse(reader, opcodeToken0); var customDataClass = opcodeToken0.DecodeValue <CustomDataClass>(11, 31); var length = reader.PeakUInt32Ahead(4); if (length == 0) { throw new Exception("Error parsing shader"); } var data = reader.ReadBytes($"Opcode{opcodeIndex}({opcodeHeader.OpcodeType}-{customDataClass})", (int)length * 4); } else if (opcodeHeader.OpcodeType.IsDeclaration()) { var data = reader.ReadBytes($"Opcode{opcodeIndex}({opcodeHeader.OpcodeType})", (int)opcodeHeader.Length * 4); } else // Not custom data or declaration, so must be instruction. { var data = reader.ReadBytes($"Opcode{opcodeIndex}({opcodeHeader.OpcodeType})", (int)opcodeHeader.Length * 4); } program.Tokens.Add(opcodeToken); } return(program); }
public static List <Number> ReadParameterValue(this DebugParameter parameter, DebugBytecodeReader valueReader) { var result = new List <Number>(); if (parameter.ParameterClass == ParameterClass.Object) { var defaultValueCount = parameter.GetSize() / 4; var data = valueReader.ReadBytes("ParameterValue", (int)defaultValueCount * 4); result.Add(new Number(data)); } else { var defaultValueCount = parameter.GetSize() / 4; var data = valueReader.ReadBytes("ParameterValue", (int)defaultValueCount * 4); for (int i = 0; i < defaultValueCount; i++) { result.Add(Number.FromByteArray(data, i * 4)); } } return(result); }
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; var entry = reader.Members.Last(); Opcode opcode = (Opcode)(instructionToken & 0xffff); entry.AddNote("TokenOpcode", opcode.ToString()); var size = (int)((instructionToken >> 16) & 0x7FFF); entry.AddNote("TokenSize", size.ToString()); 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 DebugDebugNameChunk Parse(DebugBytecodeReader reader, uint chunkSize) { var result = new DebugDebugNameChunk(); var flags = reader.ReadUInt16("Flags"); //Currently unused var nameLength = reader.ReadUInt16("NameLength"); result.Name = reader.ReadString("Name"); var padding = 4 - (nameLength + 1) % 4; //Aligned to 4 byte boundary if (padding > 0) { reader.ReadBytes("Padding", padding); } return(result); }
IDebugToken ReadInstruction(DebugBytecodeReader reader) { uint instructionToken = reader.ReadUInt32("Token"); Opcode opcode = (Opcode)(instructionToken & 0xffff); uint size; if (opcode == Opcode.Comment) { size = (uint)((instructionToken >> 16) & 0x7FFF); } else { size = (uint)((instructionToken >> 24) & 0x0f); } var entry = reader.LocalMembers.Last(); entry.AddNote("TokenOpcode", opcode.ToString()); entry.AddNote("TokenSize", size.ToString()); IDebugToken result; if (opcode == Opcode.Comment) { var token = new DebugToken(); token.Token = instructionToken; token.Opcode = opcode; token.Data = reader.ReadBytes("CommentData", (int)size * 4); result = token; } else { result = DebugInstructionToken.Parse(reader, instructionToken, opcode, size); } if (opcode != Opcode.Comment) { var token = result as DebugInstructionToken; token.Modifier = (int)((instructionToken >> 16) & 0xff); token.Predicated = (instructionToken & 0x10000000) != 0; token.CoIssue = (instructionToken & 0x40000000) != 0; entry.AddNote("Modifer", token.Modifier); entry.AddNote("Predicated", token.Predicated); entry.AddNote("CoIssue", token.CoIssue); } return(result); }
public static DebugFxlc Parse(DebugBytecodeReader reader, uint size) { var result = new DebugFxlc(); var basePosition = reader._reader.BaseStream.Position; var tokenCount = reader.ReadUInt32("TokenCount"); for (int i = 0; i < tokenCount; i++) { var token = reader.PeakUint32(); var type = (FxlcOpcode)token.DecodeValue(20, 30); reader.AddIndent($"Token{i}({type})"); result.Tokens.Add(DebugFxlcToken.Parse(reader)); reader.RemoveIndent(); } var padding = reader.ReadBytes($"Padding", 8); var paddingUint64 = BitConverter.ToInt64(padding, 0); var expected = 0x0F0F0f0FF0F0F0F0; Debug.Assert(paddingUint64 == expected); return(result); }
public static DebugBinaryData Parse(DebugBytecodeReader reader, DebugBytecodeReader blobReader) { var result = new DebugBinaryData(); result.Index = blobReader.ReadUInt32("Index"); result.Size = blobReader.ReadUInt32("Size"); var startPosition = blobReader._reader.BaseStream.Position; var header = blobReader.PeakUint32(); var shaderType = (ShaderType)(header >> 16); var paddedSize = result.Size + (result.Size % 4 == 0 ? 0 : 4 - result.Size % 4); if (shaderType == ShaderType.Pixel || shaderType == ShaderType.Vertex || shaderType == ShaderType.Expression) { var shaderReader = blobReader.CopyAtCurrentPosition("ShaderReader", blobReader); result.Shader = DebugShaderModel.Parse(shaderReader); } else if (result.Size > 0) { blobReader.ReadBytes("Value", (int)paddedSize); } blobReader._reader.BaseStream.Position = startPosition + paddedSize; return(result); }