internal static ImmutableArray <byte> CreateBlob(ArraySegment <byte> bytes) { Debug.Assert(bytes.Array != null); if (bytes.Count < CompressionThreshold) { using (Cci.PooledBlobBuilder builder = Cci.PooledBlobBuilder.GetInstance()) { builder.WriteInt32(0); builder.WriteBytes(bytes.Array, bytes.Offset, bytes.Count); return(builder.ToImmutableArray()); } } else { using (BlobBuildingStream builder = BlobBuildingStream.GetInstance()) { builder.WriteInt32(bytes.Count); using (CountingDeflateStream deflater = new CountingDeflateStream(builder, CompressionLevel.Optimal, leaveOpen: true)) { deflater.Write(bytes.Array, bytes.Offset, bytes.Count); } return(builder.ToImmutableArray()); } } }
internal virtual void Free() { if (_lazyRegularInstructions != null) { _lazyRegularInstructions.Free(); _lazyRegularInstructions = null; } }
/// <summary> /// Creates the blob to be saved to the PDB. /// </summary> internal static ImmutableArray <byte> CreateBlob(Stream stream) { Debug.Assert(stream != null); Debug.Assert(stream.CanRead); Debug.Assert(stream.CanSeek); long longLength = stream.Length; Debug.Assert(longLength >= 0); if (longLength > int.MaxValue) { throw new IOException(CodeAnalysisResources.StreamIsTooLong); } stream.Seek(0, SeekOrigin.Begin); int length = (int)longLength; if (length < CompressionThreshold) { using (Cci.PooledBlobBuilder builder = Cci.PooledBlobBuilder.GetInstance()) { builder.WriteInt32(0); int bytesWritten = builder.TryWriteBytes(stream, length); if (length != bytesWritten) { throw new EndOfStreamException(); } return(builder.ToImmutableArray()); } } else { using (BlobBuildingStream builder = BlobBuildingStream.GetInstance()) { builder.WriteInt32(length); using (CountingDeflateStream deflater = new CountingDeflateStream(builder, CompressionLevel.Optimal, leaveOpen: true)) { stream.CopyTo(deflater); if (length != deflater.BytesWritten) { throw new EndOfStreamException(); } } return(builder.ToImmutableArray()); } } }
private void RealizeBlocks() { // drop dead code. // We do not want to deal with unreachable code even when not optimizing. // sometimes dead code may have subtle verification violations // for example illegal fall-through in unreachable code is still illegal, // but compiler will not enforce returning from dead code. // it is easier to just remove dead code than make sure it is all valid MarkReachableBlocks(); RewriteSpecialBlocks(); DropUnreachableBlocks(); if (_optimizations == OptimizationLevel.Release && OptimizeLabels()) { // redo unreachable code elimination if some labels were optimized // as that could result in more dead code. MarkAllBlocksUnreachable(); MarkReachableBlocks(); DropUnreachableBlocks(); } // some gotos must become leaves RewriteBranchesAcrossExceptionHandlers(); // now we can compute block offsets and adjust branches while (ComputeOffsetsAndAdjustBranches()) { // if branches were optimized, we may have more unreachable code // redo unreachable code elimination and if anything was dropped redo adjusting. MarkAllBlocksUnreachable(); MarkReachableBlocks(); if (!DropUnreachableBlocks()) { // nothing was dropped, we are done adjusting break; } } // Now linearize everything with computed offsets. Cci.PooledBlobBuilder writer = Cci.PooledBlobBuilder.GetInstance(); for (BasicBlock block = leaderBlock; block != null; block = block.NextBlock) { // If the block has any IL markers, we can calculate their real IL offsets now int blockFirstMarker = block.FirstILMarker; if (blockFirstMarker >= 0) { int blockLastMarker = block.LastILMarker; Debug.Assert(blockLastMarker >= blockFirstMarker); for (int i = blockFirstMarker; i <= blockLastMarker; i++) { int blockOffset = _allocatedILMarkers[i].BlockOffset; int absoluteOffset = writer.Count + blockOffset; _allocatedILMarkers[i] = new ILMarker() { BlockOffset = blockOffset, AbsoluteOffset = absoluteOffset }; } } block.RegularInstructions?.WriteContentTo(writer); switch (block.BranchCode) { case ILOpCode.Nop: break; case ILOpCode.Switch: // switch (N, t1, t2... tN) // IL ==> ILOpCode.Switch < unsigned int32 > < int32 >... < int32 > WriteOpCode(writer, ILOpCode.Switch); SwitchBlock switchBlock = (SwitchBlock)block; writer.WriteUInt32(switchBlock.BranchesCount); int switchBlockEnd = switchBlock.Start + switchBlock.TotalSize; ArrayBuilder <BasicBlock> blockBuilder = ArrayBuilder <BasicBlock> .GetInstance(); switchBlock.GetBranchBlocks(blockBuilder); foreach (BasicBlock branchBlock in blockBuilder) { writer.WriteInt32(branchBlock.Start - switchBlockEnd); } blockBuilder.Free(); break; default: WriteOpCode(writer, block.BranchCode); if (block.BranchLabel != null) { int target = block.BranchBlock.Start; int curBlockEnd = block.Start + block.TotalSize; int offset = target - curBlockEnd; if (block.BranchCode.GetBranchOperandSize() == 1) { sbyte btOffset = (sbyte)offset; Debug.Assert(btOffset == offset); writer.WriteSByte(btOffset); } else { writer.WriteInt32(offset); } } break; } } this.RealizedIL = writer.ToImmutableArray(); writer.Free(); RealizeSequencePoints(); this.RealizedExceptionHandlers = _scopeManager.GetExceptionHandlerRegions(); }
internal virtual void Free() { if (_lazyRegularInstructions != null) { _lazyRegularInstructions.Free(); _lazyRegularInstructions = null; } }