private IAttribute ReadBinarySecurityAttribute(ref SRM.BlobReader reader, CustomAttributeTypedArgument <IType> securityAction) { string attributeTypeName = reader.ReadSerializedString(); IType attributeType = module.TypeProvider.GetTypeFromSerializedName(attributeTypeName); reader.ReadCompressedInteger(); // ?? // The specification seems to be incorrect here, so I'm using the logic from Cecil instead. int numNamed = reader.ReadCompressedInteger(); var decoder = new Metadata.CustomAttributeDecoder <IType>(module.TypeProvider, module.metadata); var namedArgs = decoder.DecodeNamedArguments(ref reader, numNamed); return(new DefaultAttribute( attributeType, fixedArguments: ImmutableArray.Create(securityAction), namedArguments: namedArgs)); }
private unsafe static ImmutableArray<LocalSlotDebugInfo> UncompressSlotMap(ImmutableArray<byte> compressedSlotMap) { if (compressedSlotMap.IsDefaultOrEmpty) { return default(ImmutableArray<LocalSlotDebugInfo>); } var mapBuilder = ArrayBuilder<LocalSlotDebugInfo>.GetInstance(); int syntaxOffsetBaseline = -1; fixed (byte* compressedSlotMapPtr = &compressedSlotMap.ToArray()[0]) { var blobReader = new BlobReader(compressedSlotMapPtr, compressedSlotMap.Length); while (blobReader.RemainingBytes > 0) { byte b = blobReader.ReadByte(); if (b == SyntaxOffsetBaseline) { syntaxOffsetBaseline = -blobReader.ReadCompressedInteger(); continue; } if (b == 0) { // short-lived temp, no info mapBuilder.Add(new LocalSlotDebugInfo(SynthesizedLocalKind.LoweringTemp, default(LocalDebugId))); continue; } var kind = (SynthesizedLocalKind)((b & 0x3f) - 1); bool hasOrdinal = (b & (1 << 7)) != 0; int syntaxOffset; if (!blobReader.TryReadCompressedInteger(out syntaxOffset)) { // invalid data return default(ImmutableArray<LocalSlotDebugInfo>); } syntaxOffset += syntaxOffsetBaseline; int ordinal = 0; if (hasOrdinal && !blobReader.TryReadCompressedInteger(out ordinal)) { // invalid data return default(ImmutableArray<LocalSlotDebugInfo>); } mapBuilder.Add(new LocalSlotDebugInfo(kind, new LocalDebugId(syntaxOffset, ordinal))); } } return mapBuilder.ToImmutableAndFree(); }
IAttribute ConvertMarshalInfo(SRM.BlobReader marshalInfo) { var b = new AttributeBuilder(module, KnownAttribute.MarshalAs); IType unmanagedTypeType = module.Compilation.FindType(new TopLevelTypeName(InteropServices, nameof(UnmanagedType))); int type = marshalInfo.ReadByte(); b.AddFixedArg(unmanagedTypeType, type); int size; switch (type) { case 0x1e: // FixedArray if (!marshalInfo.TryReadCompressedInteger(out size)) { size = 0; } b.AddNamedArg("SizeConst", KnownTypeCode.Int32, size); if (marshalInfo.RemainingBytes > 0) { type = marshalInfo.ReadByte(); if (type != 0x66) // None { b.AddNamedArg("ArraySubType", unmanagedTypeType, type); } } break; case 0x1d: // SafeArray if (marshalInfo.RemainingBytes > 0) { VarEnum varType = (VarEnum)marshalInfo.ReadByte(); if (varType != VarEnum.VT_EMPTY) { var varEnumType = new TopLevelTypeName(InteropServices, nameof(VarEnum)); b.AddNamedArg("SafeArraySubType", varEnumType, (int)varType); } } break; case 0x2a: // NATIVE_TYPE_ARRAY if (marshalInfo.RemainingBytes > 0) { type = marshalInfo.ReadByte(); } else { type = 0x66; // Cecil uses NativeType.None as default. } if (type != 0x50) // Max { b.AddNamedArg("ArraySubType", unmanagedTypeType, type); } int sizeParameterIndex = marshalInfo.TryReadCompressedInteger(out int value) ? value : -1; size = marshalInfo.TryReadCompressedInteger(out value) ? value : -1; int sizeParameterMultiplier = marshalInfo.TryReadCompressedInteger(out value) ? value : -1; if (size >= 0) { b.AddNamedArg("SizeConst", KnownTypeCode.Int32, size); } if (sizeParameterMultiplier != 0 && sizeParameterIndex >= 0) { b.AddNamedArg("SizeParamIndex", KnownTypeCode.Int16, (short)sizeParameterIndex); } break; case 0x2c: // CustomMarshaler string guidValue = marshalInfo.ReadSerializedString(); string unmanagedType = marshalInfo.ReadSerializedString(); string managedType = marshalInfo.ReadSerializedString(); string cookie = marshalInfo.ReadSerializedString(); if (managedType != null) { b.AddNamedArg("MarshalType", KnownTypeCode.String, managedType); } if (!string.IsNullOrEmpty(cookie)) { b.AddNamedArg("MarshalCookie", KnownTypeCode.String, cookie); } break; case 0x17: // FixedSysString b.AddNamedArg("SizeConst", KnownTypeCode.Int32, marshalInfo.ReadCompressedInteger()); break; } return(b.Build()); }
/// <exception cref="InvalidDataException">Invalid data.</exception> private unsafe static ImmutableArray<LocalSlotDebugInfo> UncompressSlotMap(ImmutableArray<byte> compressedSlotMap) { if (compressedSlotMap.IsDefaultOrEmpty) { return default(ImmutableArray<LocalSlotDebugInfo>); } var mapBuilder = ArrayBuilder<LocalSlotDebugInfo>.GetInstance(); int syntaxOffsetBaseline = -1; fixed (byte* compressedSlotMapPtr = &compressedSlotMap.ToArray()[0]) { var blobReader = new BlobReader(compressedSlotMapPtr, compressedSlotMap.Length); while (blobReader.RemainingBytes > 0) { try { // Note: integer operations below can't overflow since compressed integers are in range [0, 0x20000000) byte b = blobReader.ReadByte(); if (b == SyntaxOffsetBaseline) { syntaxOffsetBaseline = -blobReader.ReadCompressedInteger(); continue; } if (b == 0) { // short-lived temp, no info mapBuilder.Add(new LocalSlotDebugInfo(SynthesizedLocalKind.LoweringTemp, default(LocalDebugId))); continue; } var kind = (SynthesizedLocalKind)((b & 0x3f) - 1); bool hasOrdinal = (b & (1 << 7)) != 0; int syntaxOffset = blobReader.ReadCompressedInteger() + syntaxOffsetBaseline; int ordinal = hasOrdinal ? blobReader.ReadCompressedInteger() : 0; mapBuilder.Add(new LocalSlotDebugInfo(kind, new LocalDebugId(syntaxOffset, ordinal))); } catch (BadImageFormatException) { throw CreateInvalidDataException(compressedSlotMap, blobReader.Offset); } } } return mapBuilder.ToImmutableAndFree(); }
private unsafe static void UncompressLambdaMap( ImmutableArray<byte> compressedLambdaMap, out int methodOrdinal, out ImmutableArray<ClosureDebugInfo> closures, out ImmutableArray<LambdaDebugInfo> lambdas) { methodOrdinal = DebugId.UndefinedOrdinal; closures = default(ImmutableArray<ClosureDebugInfo>); lambdas = default(ImmutableArray<LambdaDebugInfo>); if (compressedLambdaMap.IsDefaultOrEmpty) { return; } var closuresBuilder = ArrayBuilder<ClosureDebugInfo>.GetInstance(); var lambdasBuilder = ArrayBuilder<LambdaDebugInfo>.GetInstance(); fixed (byte* blobPtr = &compressedLambdaMap.ToArray()[0]) { var blobReader = new BlobReader(blobPtr, compressedLambdaMap.Length); try { // Note: integer operations below can't overflow since compressed integers are in range [0, 0x20000000) // [-1, inf) methodOrdinal = blobReader.ReadCompressedInteger() - 1; int syntaxOffsetBaseline = -blobReader.ReadCompressedInteger(); int closureCount = blobReader.ReadCompressedInteger(); for (int i = 0; i < closureCount; i++) { int syntaxOffset = blobReader.ReadCompressedInteger(); var closureId = new DebugId(closuresBuilder.Count, generation: 0); closuresBuilder.Add(new ClosureDebugInfo(syntaxOffset + syntaxOffsetBaseline, closureId)); } while (blobReader.RemainingBytes > 0) { int syntaxOffset = blobReader.ReadCompressedInteger(); int closureOrdinal = blobReader.ReadCompressedInteger() + LambdaDebugInfo.MinClosureOrdinal; if (closureOrdinal >= closureCount) { throw CreateInvalidDataException(compressedLambdaMap, blobReader.Offset); } var lambdaId = new DebugId(lambdasBuilder.Count, generation: 0); lambdasBuilder.Add(new LambdaDebugInfo(syntaxOffset + syntaxOffsetBaseline, lambdaId, closureOrdinal)); } } catch (BadImageFormatException) { throw CreateInvalidDataException(compressedLambdaMap, blobReader.Offset); } } closures = closuresBuilder.ToImmutableAndFree(); lambdas = lambdasBuilder.ToImmutableAndFree(); }
private int ReadDocumentRowId(ref BlobReader reader) { int rowId = reader.ReadCompressedInteger(); if (rowId == 0) { throw new BadImageFormatException("Invalid handle"); } return rowId; }
private ushort ReadColumn(ref BlobReader reader) { int column = reader.ReadCompressedInteger(); if (column > ushort.MaxValue) { throw new BadImageFormatException("SequencePointValueOutOfRange"); } return (ushort)column; }
private int ReadLine(ref BlobReader reader) { return reader.ReadCompressedInteger(); }
private void ReadDeltaLinesAndColumns(ref BlobReader reader, out int deltaLines, out int deltaColumns) { deltaLines = reader.ReadCompressedInteger(); deltaColumns = (deltaLines == 0) ? reader.ReadCompressedInteger() : reader.ReadCompressedSignedInteger(); }
private BlobReader GetBlobReader(BlobHandle handle) { int offset = MetadataTokens.GetHeapOffset(handle); byte* start = _blobHeapBlob.Pointer + offset; var reader = new BlobReader(start, _blobHeapBlob.Length - offset); int size = reader.ReadCompressedInteger(); return new BlobReader(start + reader.Offset, size); }
private TypeSignature DecodeGenericTypeParameter( ref BlobReader signatureReader, ImmutableArray<string> typeParameters, int containingArity) { int index = signatureReader.ReadCompressedInteger(); if (index < containingArity) { // Unspecified type parameter. throw UnhandledMetadata(); } var name = typeParameters[index - containingArity]; return new QualifiedTypeSignature(null, name); }
public unsafe int GetSignature( int bufferLength, out int count, [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0), Out]byte[] signature) { var localSignatureHandle = _symMethod.MetadataReader.GetMethodBody(_symMethod.BodyHandle).LocalSignature; var metadataImport = _symMethod.SymReader.PdbReader.MetadataImport; var local = _symMethod.MetadataReader.GetLocalVariable(_handle); byte* signaturePtr; int signatureLength; int hr = metadataImport.GetSigFromToken(MetadataTokens.GetToken(localSignatureHandle), out signaturePtr, out signatureLength); if (hr != HResult.S_OK) { count = 0; return hr; } var signatureReader = new BlobReader(signaturePtr, signatureLength); SignatureHeader header = signatureReader.ReadSignatureHeader(); if (header.Kind != SignatureKind.LocalVariables) { count = 0; return HResult.E_FAIL; } int slotCount = signatureReader.ReadCompressedInteger(); int slotIndex = local.Index; if (slotIndex >= slotCount) { count = 0; return HResult.E_FAIL; } var typeProvider = new DummyTypeProvider(_symMethod.MetadataReader); for (int i = 0; i < slotIndex - 1; i++) { SignatureDecoder.DecodeType(ref signatureReader, typeProvider); } int localSlotStart = signatureReader.Offset; SignatureDecoder.DecodeType(ref signatureReader, typeProvider); int localSlotLength = signatureReader.Offset - localSlotStart; if (localSlotLength <= bufferLength) { Marshal.Copy((IntPtr)(signaturePtr + localSlotStart), signature, 0, localSlotLength); } count = localSlotLength; return HResult.S_OK; }
public bool MoveNext() { if (_reader.RemainingBytes == 0) { return(false); } DocumentHandle document = _current.Document; int offset, deltaLines, deltaColumns, startLine; ushort startColumn; if (_reader.Offset == 0) { // header (skip local signature rid): _reader.ReadCompressedInteger(); if (document.IsNil) { document = ReadDocumentHandle(); } // IL offset: offset = _reader.ReadCompressedInteger(); } else { // skip all document records and update the current document accordingly: int deltaOffset; while ((deltaOffset = _reader.ReadCompressedInteger()) == 0) { document = ReadDocumentHandle(); } // IL offset: offset = AddOffsets(_current.Offset, deltaOffset); } ReadDeltaLinesAndColumns(out deltaLines, out deltaColumns); // hidden if (deltaLines == 0 && deltaColumns == 0) { _current = new SequencePoint(document, offset); return(true); } // delta Start Line & Column: if (_previousNonHiddenStartLine < 0) { Debug.Assert(_previousNonHiddenStartColumn == 0); startLine = ReadLine(); startColumn = ReadColumn(); } else { startLine = AddLines(_previousNonHiddenStartLine, _reader.ReadCompressedSignedInteger()); startColumn = AddColumns(_previousNonHiddenStartColumn, _reader.ReadCompressedSignedInteger()); } _previousNonHiddenStartLine = startLine; _previousNonHiddenStartColumn = startColumn; _current = new SequencePoint( document, offset, startLine, startColumn, AddLines(startLine, deltaLines), AddColumns(startColumn, deltaColumns)); return(true); }