internal void UpdateVersion(ShaderVersion version) { if (Reader == null) { return; } Reader.ReadUInt32(); //Unknown switch (version.ProgramType) { case ProgramType.VertexShader: Info = VSInfo.Parse(Reader); break; case ProgramType.HullShader: Info = HSInfo.Parse(Reader); break; case ProgramType.DomainShader: Info = DSInfo.Parse(Reader); break; case ProgramType.GeometryShader: Info = GSInfo.Parse(Reader); break; case ProgramType.PixelShader: Info = PSInfo.Parse(Reader); break; default: Reader.ReadBytes(ValidationInfo.UnionSize); break; } if (Info != null && Info.StructSize < ValidationInfo.UnionSize) { //Padding Reader.ReadBytes(ValidationInfo.UnionSize - Info.StructSize); } MinimumExpectedWaveLaneCount = Reader.ReadUInt32(); MaximumExpectedWaveLaneCount = Reader.ReadUInt32(); if (ChunkSize > 20) { var shaderKind = (PSVShaderKind)Reader.ReadByte(); UsesViewID = Reader.ReadByte(); GSMaxVertexCount = Reader.ReadByte(); SigInputElements = Reader.ReadByte(); SigOutputElements = Reader.ReadByte(); SigPatchConstOrPrimElements = Reader.ReadByte(); SigInputVectors = Reader.ReadByte(); SigOutputVectors = Reader.ReadBytes(4); } Reader = null; }
public static RuntimeDataChunk Parse(BytecodeReader reader, uint chunkSize) { var result = new RuntimeDataChunk(); result.RawData = reader.ReadBytes((int)chunkSize); return(result); }
public static ShaderMessageDeclarationToken Parse(BytecodeReader reader) { var token0 = reader.ReadUInt32(); var length = reader.ReadUInt32() - 2; var result = new ShaderMessageDeclarationToken { DeclarationLength = length, InfoQueueMessageID = reader.ReadUInt32(), MessageFormat = (ShaderMessageFormat)reader.ReadUInt32(), NumCharacters = reader.ReadUInt32(), NumOperands = reader.ReadUInt32(), OperandsLength = reader.ReadUInt32() }; for (int i = 0; i < result.NumOperands; i++) { result.Operands.Add(Operand.Parse(reader, OpcodeType.CustomData)); } result.Format = reader.ReadString(); // String is padded to a multiple of DWORDs. uint remainingBytes = (4 - ((result.NumCharacters + 1) % 4)) % 4; reader.ReadBytes((int)remainingBytes); return(result); }
public static VariableBlob Parse(BytecodeReader reader, BytecodeReader dataReader) { var result = new VariableBlob(); result.Index = dataReader.ReadUInt32(); var blobSize = dataReader.ReadUInt32(); var paddedSize = blobSize + (blobSize % 4 == 0 ? 0 : 4 - blobSize % 4); var shaderReader = dataReader.CopyAtCurrentPosition(); var data = dataReader.ReadBytes((int)paddedSize); if (!_IsShader(data)) { if (blobSize == 0) { result.Value = ""; } else { result.Value = Encoding.UTF8.GetString(data, 0, (int)(blobSize - 1)); } } else { result.Shader = ShaderModel.Parse(shaderReader); } return(result); }
public static PrivateChunk Parse(BytecodeReader reader, uint chunkSize) { var result = new PrivateChunk(); result.PrivateData = reader.ReadBytes((int)chunkSize); return(result); }
public static HashChunk Parse(BytecodeReader reader, uint chunkSize) { var result = new HashChunk() { Flags = (HashFlags)reader.ReadUInt32(), Digest = reader.ReadBytes(DigestSize) }; return(result); }
public new static EffectExpressionAssignment Parse(BytecodeReader reader, BytecodeReader assignmentReader) { var result = new EffectExpressionAssignment(); var shaderSize = assignmentReader.ReadUInt32(); if (shaderSize != 0) { result.Shader = BytecodeContainer.Parse(assignmentReader.ReadBytes((int)shaderSize)); } return(result); }
public static DebuggingChunk Parse(BytecodeReader reader, ChunkType chunkType, int chunkSize) { var result = new DebuggingChunk(); if (chunkType == ChunkType.Sdbg) // SDGB is not supported. { return(result); } result.PdbBytes = reader.ReadBytes(chunkSize); return(result); }
public static string TryReadString(this BytecodeReader reader) { try { var length = reader.ReadUInt32(); if (length == 0) { return(""); } var bytes = reader.ReadBytes((int)length); return(Encoding.UTF8.GetString(bytes, 0, bytes.Length - 1)); } catch (Exception ex) { return("Error reading string"); } }
public static StateBlob Parse(BytecodeReader reader, BytecodeReader shaderReader) { var result = new StateBlob(); result.TechniqueIndex = shaderReader.ReadUInt32(); result.PassIndex = shaderReader.ReadUInt32(); result.SamplerStateIndex = shaderReader.ReadUInt32(); result.AssignmentIndex = shaderReader.ReadUInt32(); result.BlobType = (StateBlobType)shaderReader.ReadUInt32(); var dataReader = shaderReader.CopyAtCurrentPosition(); var blobSize = shaderReader.ReadUInt32(); var paddedSize = blobSize + (blobSize % 4 == 0 ? 0 : 4 - blobSize % 4); //Seak ahead var data = shaderReader.ReadBytes((int)paddedSize); if (result.BlobType == StateBlobType.Shader) { result.Shader = ShaderReader.ReadShader(data); } else if (result.BlobType == StateBlobType.Variable) { result.VariableName = dataReader.TryReadString(); } else if (result.BlobType == StateBlobType.IndexShader) { var _blobSize = dataReader.ReadUInt32(); var variableSize = dataReader.ReadUInt32(); result.VariableName = dataReader.ReadString(); if (variableSize > (result.VariableName.Length + 1)) { var paddingCount = variableSize - (result.VariableName.Length + 1); var padding = dataReader.ReadBytes((int)paddingCount); } result.Shader = result.Shader = ShaderModel.Parse(dataReader); } return(result); }
public static Attributes ReadAttributes(BytecodeReader reader, ushort attributesCount) { Attributes attributes = new Attributes(); Dictionary <String, Action> attributeNameDictionary = new Dictionary <string, Action>(); attributeNameDictionary.Add("Code", () => { ushort attributeNameIndex = reader.ReadUShort(); uint attributeLength = reader.ReadUInt(); ushort maxStack = reader.ReadUShort(); ushort maxLocals = reader.ReadUShort(); uint codeLength = reader.ReadUInt(); byte[] code = reader.ReadBytes(codeLength); ushort exceptionTableLength = reader.ReadUShort(); byte[] exceptionTable = reader.ReadBytes((uint)exceptionTableLength * 8); ushort codeAttributesCount = reader.ReadUShort(); Attributes codeAttributes = ReadAttributes(reader, codeAttributesCount); attributes.AddAttributeCode(attributeNameIndex, attributeLength, maxStack, maxLocals, codeLength, code, exceptionTableLength, exceptionTable, attributesCount, attributes); }); short attributeIndex = 0; var attributesTable = new List <AttributeSuper>(); int curAttributeNameIndex; while (attributesCount > attributeIndex) { curAttributeNameIndex = bytecode[index] * 0x100 + bytecode[index + 1]; switch (cp.getConstantUtf8(curAttributeNameIndex).Value) { case "Code": attributesTable.Add(AttributeCode.Create(bytecode, cp)); attributeIndex++; break; case "ConstantValue": // TODO: not skipping bytes Console.WriteLine("ConstantValue attribute was created"); attributesTable.Add(AttributeSuper.Create(bytecode)); index += (int)attributesTable.Last().AttributeLength; attributeIndex++; break; case "StackMapTable": // TODO: not skipping bytes Console.WriteLine("StackMapTable attribute was created"); attributesTable.Add(AttributeSuper.Create(bytecode)); index += (int)attributesTable.Last().AttributeLength; attributeIndex++; break; case "BootstrapMethods": // TODO: not skipping bytes Console.WriteLine("BootstrapMethods attribute was created"); attributesTable.Add(AttributeSuper.Create(bytecode)); index += (int)attributesTable.Last().AttributeLength; attributeIndex++; break; case "LineNumberTable": attributesTable.Add(AttributeLineNumberTable.Create(bytecode, cp)); attributeIndex++; break; case "SourceFile": attributesTable.Add(AttributeSourceFile.Create(bytecode, cp)); attributeIndex++; break; default: attributeIndex++; Console.WriteLine("no attribute found"); break; } } return(new Attributes(attributesTable)); }
Token ReadInstruction(BytecodeReader reader) { uint instructionToken = reader.ReadUInt32(); Opcode opcode = (Opcode)(instructionToken & 0xffff); int size; if (opcode == Opcode.Comment) { size = (int)((instructionToken >> 16) & 0x7FFF); } else { size = (int)((instructionToken >> 24) & 0x0f); } Token token = null; if (opcode == Opcode.Comment) { var fourCC = reader.ReadUInt32(); if (KnownCommentTypes.ContainsKey(fourCC)) { var commentReader = reader.CopyAtCurrentPosition(); reader.ReadBytes(size * 4 - 4); switch (KnownCommentTypes[fourCC]) { case CommentType.CTAB: ConstantTable = ConstantTable.Parse(commentReader); return(null); case CommentType.C**T: Cli = CliToken.Parse(commentReader); return(null); case CommentType.FXLC: Fxlc = FxlcBlock.Parse(commentReader); return(null); case CommentType.PRES: Preshader = Preshader.Parse(commentReader); return(null); case CommentType.PRSI: Prsi = PrsiToken.Parse(commentReader); return(null); } } token = new CommentToken(opcode, size, this); token.Data[0] = fourCC; for (int i = 1; i < size; i++) { token.Data[i] = reader.ReadUInt32(); } } else { token = new InstructionToken(opcode, size, this); var inst = token as InstructionToken; for (int i = 0; i < size; i++) { token.Data[i] = reader.ReadUInt32(); if (opcode == Opcode.Def || opcode == Opcode.DefB || opcode == Opcode.DefI) { if (i == 0) { inst.Operands.Add(new DestinationOperand(token.Data[i])); } } else if (opcode == Opcode.Dcl) { if (i == 0) { inst.Operands.Add(new DeclarationOperand(token.Data[i])); } else { inst.Operands.Add(new DestinationOperand(token.Data[i])); } } else if (i == 0 && opcode.HasDestination()) { if ((token.Data[i] & (1 << 13)) != 0) { //Relative Address mode token.Data[i + 1] = reader.ReadUInt32(); inst.Operands.Add(new DestinationOperand(token.Data[i], token.Data[i + 1])); i++; } else { inst.Operands.Add(new DestinationOperand(token.Data[i])); } } else if ((token.Data[i] & (1 << 13)) != 0) { //Relative Address mode token.Data[i + 1] = reader.ReadUInt32(); inst.Operands.Add(new SourceOperand(token.Data[i], token.Data[i + 1])); i++; } else { inst.Operands.Add(new SourceOperand(token.Data[i])); } } if (opcode != Opcode.Comment) { token.Modifier = (int)((instructionToken >> 16) & 0xff); token.Predicated = (instructionToken & 0x10000000) != 0; token.CoIssue = (instructionToken & 0x40000000) != 0; Debug.Assert((instructionToken & 0xA0000000) == 0, $"Instruction has unexpected bits set {instructionToken & 0xE0000000}"); } } return(token); }