public unsafe void TinyBody()
{
var streamBuilder = new BlobBuilder();
var codeBuilder = new BlobBuilder();
var flowBuilder = new ControlFlowBuilder();
var il = new InstructionEncoder(codeBuilder, flowBuilder);
codeBuilder.WriteBytes(1, 61);
var l1 = il.DefineLabel();
il.MarkLabel(l1);
Assert.Equal(61, flowBuilder.Labels.Single());
il.Branch(ILOpCode.Br_s, l1);
var brInfo = flowBuilder.Branches.Single();
Assert.Equal(61, brInfo.ILOffset);
Assert.Equal(l1, brInfo.Label);
Assert.Equal(ILOpCode.Br_s, brInfo.OpCode);
AssertEx.Equal(new byte[] { 1, (byte)ILOpCode.Br_s, unchecked ((byte)-1) }, codeBuilder.ToArray(60, 3));
var streamEncoder = new MethodBodyStreamEncoder(streamBuilder);
int bodyOffset = streamEncoder.AddMethodBody(
il,
maxStack: 2,
localVariablesSignature: default,
static byte[] GenerateSampleIL(ControlFlowBuilder cfb)
{
var code = new BlobBuilder();
var il = new InstructionEncoder(code, cfb);
var l1 = il.DefineLabel();
var l2 = il.DefineLabel();
var l3 = il.DefineLabel();
var l4 = il.DefineLabel();
il.MarkLabel(l1);
il.OpCode(ILOpCode.Nop);
il.Branch(ILOpCode.Br_s, l1);
il.MarkLabel(l2);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l3);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l4);
cfb.AddCatchRegion(l1, l2, l3, l4, MetadataTokens.TypeDefinitionHandle(1));
var builder = new BlobBuilder();
new MethodBodyStreamEncoder(builder).AddMethodBody(il);
return(builder.ToArray());
}
public void Branch_LongInstruction_ShortDistance()
{
var code = new BlobBuilder();
var flow = new ControlFlowBuilder();
var il = new InstructionEncoder(code, flow);
var l1 = il.DefineLabel();
il.Branch(ILOpCode.Br, l1);
il.Call(MetadataTokens.MethodDefinitionHandle(1));
il.MarkLabel(l1);
il.OpCode(ILOpCode.Ret);
var builder = new BlobBuilder();
new MethodBodyStreamEncoder(builder).AddMethodBody(il);
AssertEx.Equal(new byte[]
{
0x2E, // header
(byte)ILOpCode.Br, 0x05, 0x00, 0x00, 0x00,
(byte)ILOpCode.Call, 0x01, 0x00, 0x00, 0x06,
(byte)ILOpCode.Ret
}, builder.ToArray());
}
private static void WriteFakeILWithBranches(BlobBuilder builder, ControlFlowBuilder branchBuilder, int size)
{
Assert.Equal(0, builder.Count);
const byte filling = 0x01;
int ilOffset = 0;
foreach (var branch in branchBuilder.Branches)
{
builder.WriteBytes(filling, branch.ILOffset - ilOffset);
Assert.Equal(branch.ILOffset, builder.Count);
builder.WriteByte((byte)branch.OpCode);
int operandSize = branch.OpCode.GetBranchOperandSize();
if (operandSize == 1)
{
builder.WriteSByte(-1);
}
else
{
builder.WriteInt32(-1);
}
ilOffset = branch.ILOffset + sizeof(byte) + operandSize;
}
builder.WriteBytes(filling, size - ilOffset);
Assert.Equal(size, builder.Count);
}
private static void WriteFakeILWithBranches(BlobBuilder builder, ControlFlowBuilder branchBuilder, int size)
{
Assert.Equal(0, builder.Count);
const byte filling = 0x01;
int ilOffset = 0;
foreach (var branch in branchBuilder.Branches)
{
builder.WriteBytes(filling, branch.ILOffset - ilOffset);
Assert.Equal(branch.ILOffset, builder.Count);
builder.WriteByte((byte)branch.OpCode);
int operandSize = branch.OpCode.GetBranchOperandSize();
if (operandSize == 1)
{
builder.WriteSByte(-1);
}
else
{
builder.WriteInt32(-1);
}
ilOffset = branch.ILOffset + sizeof(byte) + operandSize;
}
builder.WriteBytes(filling, size - ilOffset);
Assert.Equal(size, builder.Count);
}
public void AddRegion_Errors3()
{
var code = new BlobBuilder();
var flow = new ControlFlowBuilder();
var il = new InstructionEncoder(code, flow);
var l1 = il.DefineLabel();
var l2 = il.DefineLabel();
var l3 = il.DefineLabel();
var l4 = il.DefineLabel();
var l5 = il.DefineLabel();
il.MarkLabel(l1);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l2);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l3);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l4);
var streamBuilder = new BlobBuilder();
var encoder = new MethodBodyStreamEncoder(streamBuilder);
flow.AddFaultRegion(l1, l2, l4, l3);
Assert.Throws <InvalidOperationException>(() => encoder.AddMethodBody(il));
}
protected override void Run(ICSharpTreeNode element, ElementProblemAnalyzerData data, IHighlightingConsumer consumer)
{
var controlFlowGraph = (ICSharpControlFlowGraph)ControlFlowBuilder.GetGraph(element);
if (controlFlowGraph != null)
{
AnalyzeAssertions(data, consumer, element, controlFlowGraph);
}
}
public void Clear()
{
var cfb = new ControlFlowBuilder();
var il1 = GenerateSampleIL(cfb);
cfb.Clear();
var il2 = GenerateSampleIL(cfb);
AssertEx.Equal(il1, il2);
public void Ctor()
{
var code = new BlobBuilder();
var flow = new ControlFlowBuilder();
var ie = new InstructionEncoder(code, flow);
Assert.Same(ie.CodeBuilder, code);
Assert.Same(ie.ControlFlowBuilder, flow);
Assert.Throws<ArgumentNullException>(() => new InstructionEncoder(null));
}
public void Ctor()
{
var code = new BlobBuilder();
var flow = new ControlFlowBuilder();
var ie = new InstructionEncoder(code, flow);
Assert.Same(ie.CodeBuilder, code);
Assert.Same(ie.ControlFlowBuilder, flow);
Assert.Throws <ArgumentNullException>(() => new InstructionEncoder(null));
}
public void Branches1()
{
var flowBuilder = new ControlFlowBuilder();
var l0 = flowBuilder.AddLabel();
var l64 = flowBuilder.AddLabel();
var l255 = flowBuilder.AddLabel();
flowBuilder.MarkLabel(0, l0);
flowBuilder.MarkLabel(64, l64);
flowBuilder.MarkLabel(255, l255);
flowBuilder.AddBranch(0, l255, ILOpCode.Bge);
flowBuilder.AddBranch(16, l0, ILOpCode.Bge_un_s); // blob boundary
flowBuilder.AddBranch(33, l255, ILOpCode.Ble); // blob boundary
flowBuilder.AddBranch(38, l0, ILOpCode.Ble_un_s); // branches immediately next to each other
flowBuilder.AddBranch(40, l255, ILOpCode.Blt); // branches immediately next to each other
flowBuilder.AddBranch(46, l64, ILOpCode.Blt_un_s);
flowBuilder.AddBranch(254, l0, ILOpCode.Brfalse); // long branch at the end
var dstBuilder = new BlobBuilder();
var srcBuilder = new BlobBuilder(capacity: 17);
WriteFakeILWithBranches(srcBuilder, flowBuilder, size: 259);
flowBuilder.CopyCodeAndFixupBranches(srcBuilder, dstBuilder);
AssertEx.Equal(new byte[]
{
(byte)ILOpCode.Bge, 0xFA, 0x00, 0x00, 0x00,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
(byte)ILOpCode.Bge_un_s, 0xEE,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
(byte)ILOpCode.Ble, 0xD9, 0x00, 0x00, 0x00,
(byte)ILOpCode.Ble_un_s, 0xD8,
(byte)ILOpCode.Blt, 0xD2, 0x00, 0x00, 0x00,
0x01,
(byte)ILOpCode.Blt_un_s, 0x10,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
(byte)ILOpCode.Brfalse, 0xFD, 0xFE, 0xFF, 0xFF,
}, dstBuilder.ToArray());
}
public void BranchErrors_UnmarkedLabel()
{
var streamBuilder = new BlobBuilder();
var codeBuilder = new BlobBuilder();
var flowBuilder = new ControlFlowBuilder();
var il = new InstructionEncoder(codeBuilder, flowBuilder);
var l = il.DefineLabel();
il.Branch(ILOpCode.Br_s, l);
il.OpCode(ILOpCode.Ret);
Assert.Throws <InvalidOperationException>(() => new MethodBodyStreamEncoder(streamBuilder).AddMethodBody(il));
}
public void AddRegion_Errors1()
{
var code = new BlobBuilder();
var flow = new ControlFlowBuilder();
var il = new InstructionEncoder(code, flow);
var ilx = new InstructionEncoder(code, new ControlFlowBuilder());
var l1 = il.DefineLabel();
var l2 = il.DefineLabel();
var l3 = il.DefineLabel();
var l4 = il.DefineLabel();
var l5 = il.DefineLabel();
ilx.DefineLabel();
ilx.DefineLabel();
ilx.DefineLabel();
ilx.DefineLabel();
ilx.DefineLabel();
ilx.DefineLabel();
var lx = ilx.DefineLabel();
il.MarkLabel(l1);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l2);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l3);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l4);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l5);
Assert.Throws <ArgumentException>(() => flow.AddCatchRegion(l1, l2, l3, l4, default(TypeDefinitionHandle)));
Assert.Throws <ArgumentException>(() => flow.AddCatchRegion(l1, l2, l3, l4, MetadataTokens.MethodDefinitionHandle(1)));
Assert.Throws <ArgumentNullException>(() => flow.AddCatchRegion(default(LabelHandle), l2, l3, l4, MetadataTokens.TypeReferenceHandle(1)));
Assert.Throws <ArgumentNullException>(() => flow.AddCatchRegion(l1, default(LabelHandle), l3, l4, MetadataTokens.TypeReferenceHandle(1)));
Assert.Throws <ArgumentNullException>(() => flow.AddCatchRegion(l1, l2, default(LabelHandle), l4, MetadataTokens.TypeReferenceHandle(1)));
Assert.Throws <ArgumentNullException>(() => flow.AddCatchRegion(l1, l2, l3, default(LabelHandle), MetadataTokens.TypeReferenceHandle(1)));
Assert.Throws <ArgumentException>(() => flow.AddCatchRegion(lx, l2, l3, l4, MetadataTokens.TypeReferenceHandle(1)));
Assert.Throws <ArgumentException>(() => flow.AddCatchRegion(l1, lx, l3, l4, MetadataTokens.TypeReferenceHandle(1)));
Assert.Throws <ArgumentException>(() => flow.AddCatchRegion(l1, l2, lx, l4, MetadataTokens.TypeReferenceHandle(1)));
Assert.Throws <ArgumentException>(() => flow.AddCatchRegion(l1, l2, l3, lx, MetadataTokens.TypeReferenceHandle(1)));
}
public ICSharpControlFlowGraph GetControlFlowGraph()
{
if (!_controlFlowGraphCached)
{
if (this.SelectedElement is ICSharpTreeNode)
{
ITreeNode containingGraphOwner = ControlFlowBuilder.GetContainingGraphOwner(this.SelectedElement);
if (containingGraphOwner != null)
{
new CachingNonQualifiedReferencesResolver().Process(containingGraphOwner);
_cachedControlFlowGraph = ControlFlowBuilder.GetGraph(containingGraphOwner) as ICSharpControlFlowGraph;
}
}
_controlFlowGraphCached = true;
}
return(_cachedControlFlowGraph);
}
public void BranchErrors()
{
var codeBuilder = new BlobBuilder();
var il = new InstructionEncoder(codeBuilder);
Assert.Throws <InvalidOperationException>(() => il.DefineLabel());
il = new InstructionEncoder(codeBuilder, new ControlFlowBuilder());
il.DefineLabel();
il.DefineLabel();
var l2 = il.DefineLabel();
var flowBuilder = new ControlFlowBuilder();
il = new InstructionEncoder(codeBuilder, flowBuilder);
var l0 = il.DefineLabel();
Assert.Throws <ArgumentException>(() => il.Branch(ILOpCode.Nop, l0));
Assert.Throws <ArgumentNullException>(() => il.Branch(ILOpCode.Br, default(LabelHandle)));
Assert.Throws <ArgumentException>(() => il.Branch(ILOpCode.Br, l2));
}
public void Branch_ShortInstruction_LongDistance()
{
var code = new BlobBuilder();
var flow = new ControlFlowBuilder();
var il = new InstructionEncoder(code, flow);
var l1 = il.DefineLabel();
il.Branch(ILOpCode.Br_s, l1);
for (int i = 0; i < 100; i++)
{
il.Call(MetadataTokens.MethodDefinitionHandle(1));
}
il.MarkLabel(l1);
il.OpCode(ILOpCode.Ret);
var builder = new BlobBuilder();
var encoder = new MethodBodyStreamEncoder(builder);
Assert.Throws <InvalidOperationException>(() => encoder.AddMethodBody(il));
}
public void AddRegion_Errors3()
{
var code = new BlobBuilder();
var flow = new ControlFlowBuilder();
var il = new InstructionEncoder(code, flow);
var l1 = il.DefineLabel();
var l2 = il.DefineLabel();
var l3 = il.DefineLabel();
var l4 = il.DefineLabel();
var l5 = il.DefineLabel();
il.MarkLabel(l1);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l2);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l3);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l4);
var streamBuilder = new BlobBuilder();
var encoder = new MethodBodyStreamEncoder(streamBuilder);
flow.AddFaultRegion(l1, l2, l4, l3);
Assert.Throws<InvalidOperationException>(() => encoder.AddMethodBody(il));
}
public unsafe void FatBody()
{
var streamBuilder = new BlobBuilder();
var codeBuilder = new BlobBuilder();
var flowBuilder = new ControlFlowBuilder();
var il = new InstructionEncoder(codeBuilder, flowBuilder);
codeBuilder.WriteBytes(1, 62);
var l1 = il.DefineLabel();
il.MarkLabel(l1);
Assert.Equal(62, flowBuilder.Labels.Single());
il.Branch(ILOpCode.Br_s, l1);
var brInfo = flowBuilder.Branches.Single();
Assert.Equal(62, brInfo.ILOffset);
Assert.Equal(l1, brInfo.Label);
Assert.Equal(ILOpCode.Br_s, brInfo.OpCode);
AssertEx.Equal(new byte[] { 1, 1, (byte)ILOpCode.Br_s, unchecked ((byte)-1) }, codeBuilder.ToArray(60, 4));
var streamEncoder = new MethodBodyStreamEncoder(streamBuilder);
int bodyOffset = streamEncoder.AddMethodBody(
il,
maxStack: 2,
localVariablesSignature: default(StandaloneSignatureHandle),
attributes: MethodBodyAttributes.None);
var bodyBytes = streamBuilder.ToArray();
AssertEx.Equal(new byte[]
{
0x03, 0x30, 0x02, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // fat header
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x2B, 0xFE
}, bodyBytes);
fixed(byte *bodyPtr = &bodyBytes[0])
{
var body = MethodBodyBlock.Create(new BlobReader(bodyPtr, bodyBytes.Length));
Assert.Equal(0, body.ExceptionRegions.Length);
Assert.Equal(default(StandaloneSignatureHandle), body.LocalSignature);
Assert.Equal(2, body.MaxStack);
Assert.Equal(bodyBytes.Length, body.Size);
var ilBytes = body.GetILBytes();
AssertEx.Equal(new byte[]
{
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x2B, 0xFE
}, ilBytes);
}
}
public void AddRegion_Errors1()
{
var code = new BlobBuilder();
var flow = new ControlFlowBuilder();
var il = new InstructionEncoder(code, flow);
var ilx = new InstructionEncoder(code, new ControlFlowBuilder());
var l1 = il.DefineLabel();
var l2 = il.DefineLabel();
var l3 = il.DefineLabel();
var l4 = il.DefineLabel();
var l5 = il.DefineLabel();
ilx.DefineLabel();
ilx.DefineLabel();
ilx.DefineLabel();
ilx.DefineLabel();
ilx.DefineLabel();
ilx.DefineLabel();
var lx = ilx.DefineLabel();
il.MarkLabel(l1);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l2);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l3);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l4);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l5);
Assert.Throws<ArgumentException>(() => flow.AddCatchRegion(l1, l2, l3, l4, default(TypeDefinitionHandle)));
Assert.Throws<ArgumentException>(() => flow.AddCatchRegion(l1, l2, l3, l4, MetadataTokens.MethodDefinitionHandle(1)));
Assert.Throws<ArgumentNullException>(() => flow.AddCatchRegion(default(LabelHandle), l2, l3, l4, MetadataTokens.TypeReferenceHandle(1)));
Assert.Throws<ArgumentNullException>(() => flow.AddCatchRegion(l1, default(LabelHandle), l3, l4, MetadataTokens.TypeReferenceHandle(1)));
Assert.Throws<ArgumentNullException>(() => flow.AddCatchRegion(l1, l2, default(LabelHandle), l4, MetadataTokens.TypeReferenceHandle(1)));
Assert.Throws<ArgumentNullException>(() => flow.AddCatchRegion(l1, l2, l3, default(LabelHandle), MetadataTokens.TypeReferenceHandle(1)));
Assert.Throws<ArgumentException>(() => flow.AddCatchRegion(lx, l2, l3, l4, MetadataTokens.TypeReferenceHandle(1)));
Assert.Throws<ArgumentException>(() => flow.AddCatchRegion(l1, lx, l3, l4, MetadataTokens.TypeReferenceHandle(1)));
Assert.Throws<ArgumentException>(() => flow.AddCatchRegion(l1, l2, lx, l4, MetadataTokens.TypeReferenceHandle(1)));
Assert.Throws<ArgumentException>(() => flow.AddCatchRegion(l1, l2, l3, lx, MetadataTokens.TypeReferenceHandle(1)));
}
private static MethodDefinitionHandle BasicValidationEmit(MetadataBuilder metadata, BlobBuilder ilBuilder)
{
metadata.AddModule(
0,
metadata.GetOrAddString("ConsoleApplication.exe"),
metadata.GetOrAddGuid(s_guid),
default(GuidHandle),
default(GuidHandle));
metadata.AddAssembly(
metadata.GetOrAddString("ConsoleApplication"),
version: new Version(1, 0, 0, 0),
culture: default(StringHandle),
publicKey: metadata.GetOrAddBlob(ImmutableArray.Create(Misc.KeyPair_PublicKey)),
flags: AssemblyFlags.PublicKey,
hashAlgorithm: AssemblyHashAlgorithm.Sha1);
var mscorlibAssemblyRef = metadata.AddAssemblyReference(
name: metadata.GetOrAddString("mscorlib"),
version: new Version(4, 0, 0, 0),
culture: default(StringHandle),
publicKeyOrToken: metadata.GetOrAddBlob(ImmutableArray.Create <byte>(0xB7, 0x7A, 0x5C, 0x56, 0x19, 0x34, 0xE0, 0x89)),
flags: default(AssemblyFlags),
hashValue: default(BlobHandle));
var systemObjectTypeRef = metadata.AddTypeReference(
mscorlibAssemblyRef,
metadata.GetOrAddString("System"),
metadata.GetOrAddString("Object"));
var systemConsoleTypeRefHandle = metadata.AddTypeReference(
mscorlibAssemblyRef,
metadata.GetOrAddString("System"),
metadata.GetOrAddString("Console"));
var consoleWriteLineSignature = new BlobBuilder();
new BlobEncoder(consoleWriteLineSignature).
MethodSignature().
Parameters(1,
returnType => returnType.Void(),
parameters => parameters.AddParameter().Type().String());
var consoleWriteLineMemberRef = metadata.AddMemberReference(
systemConsoleTypeRefHandle,
metadata.GetOrAddString("WriteLine"),
metadata.GetOrAddBlob(consoleWriteLineSignature));
var parameterlessCtorSignature = new BlobBuilder();
new BlobEncoder(parameterlessCtorSignature).
MethodSignature(isInstanceMethod: true).
Parameters(0, returnType => returnType.Void(), parameters => { });
var parameterlessCtorBlobIndex = metadata.GetOrAddBlob(parameterlessCtorSignature);
var objectCtorMemberRef = metadata.AddMemberReference(
systemObjectTypeRef,
metadata.GetOrAddString(".ctor"),
parameterlessCtorBlobIndex);
var mainSignature = new BlobBuilder();
new BlobEncoder(mainSignature).
MethodSignature().
Parameters(0, returnType => returnType.Void(), parameters => { });
var methodBodyStream = new MethodBodyStreamEncoder(ilBuilder);
var codeBuilder = new BlobBuilder();
InstructionEncoder il;
//
// Program::.ctor
//
il = new InstructionEncoder(codeBuilder);
// ldarg.0
il.LoadArgument(0);
// call instance void [mscorlib]System.Object::.ctor()
il.Call(objectCtorMemberRef);
// ret
il.OpCode(ILOpCode.Ret);
int ctorBodyOffset = methodBodyStream.AddMethodBody(il);
codeBuilder.Clear();
//
// Program::Main
//
var flowBuilder = new ControlFlowBuilder();
il = new InstructionEncoder(codeBuilder, flowBuilder);
var tryStart = il.DefineLabel();
var tryEnd = il.DefineLabel();
var finallyStart = il.DefineLabel();
var finallyEnd = il.DefineLabel();
flowBuilder.AddFinallyRegion(tryStart, tryEnd, finallyStart, finallyEnd);
// .try
il.MarkLabel(tryStart);
// ldstr "hello"
il.LoadString(metadata.GetOrAddUserString("hello"));
// call void [mscorlib]System.Console::WriteLine(string)
il.Call(consoleWriteLineMemberRef);
// leave.s END
il.Branch(ILOpCode.Leave_s, finallyEnd);
il.MarkLabel(tryEnd);
// .finally
il.MarkLabel(finallyStart);
// ldstr "world"
il.LoadString(metadata.GetOrAddUserString("world"));
// call void [mscorlib]System.Console::WriteLine(string)
il.Call(consoleWriteLineMemberRef);
// .endfinally
il.OpCode(ILOpCode.Endfinally);
il.MarkLabel(finallyEnd);
// ret
il.OpCode(ILOpCode.Ret);
int mainBodyOffset = methodBodyStream.AddMethodBody(il);
codeBuilder.Clear();
flowBuilder.Clear();
var mainMethodDef = metadata.AddMethodDefinition(
MethodAttributes.Public | MethodAttributes.Static | MethodAttributes.HideBySig,
MethodImplAttributes.IL | MethodImplAttributes.Managed,
metadata.GetOrAddString("Main"),
metadata.GetOrAddBlob(mainSignature),
mainBodyOffset,
parameterList: default(ParameterHandle));
var ctorDef = metadata.AddMethodDefinition(
MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName,
MethodImplAttributes.IL | MethodImplAttributes.Managed,
metadata.GetOrAddString(".ctor"),
parameterlessCtorBlobIndex,
ctorBodyOffset,
parameterList: default(ParameterHandle));
metadata.AddTypeDefinition(
default(TypeAttributes),
default(StringHandle),
metadata.GetOrAddString("<Module>"),
baseType: default(EntityHandle),
fieldList: MetadataTokens.FieldDefinitionHandle(1),
methodList: mainMethodDef);
metadata.AddTypeDefinition(
TypeAttributes.Class | TypeAttributes.Public | TypeAttributes.AutoLayout | TypeAttributes.BeforeFieldInit,
metadata.GetOrAddString("ConsoleApplication"),
metadata.GetOrAddString("Program"),
systemObjectTypeRef,
fieldList: MetadataTokens.FieldDefinitionHandle(1),
methodList: mainMethodDef);
return(mainMethodDef);
}
public void BranchErrors_UnmarkedLabel()
{
var streamBuilder = new BlobBuilder();
var codeBuilder = new BlobBuilder();
var flowBuilder = new ControlFlowBuilder();
var il = new InstructionEncoder(codeBuilder, flowBuilder);
var l = il.DefineLabel();
il.Branch(ILOpCode.Br_s, l);
il.OpCode(ILOpCode.Ret);
Assert.Throws<InvalidOperationException>(() => new MethodBodyStreamEncoder(streamBuilder).AddMethodBody(il));
}
public void BranchErrors()
{
var codeBuilder = new BlobBuilder();
var il = new InstructionEncoder(codeBuilder);
Assert.Throws<InvalidOperationException>(() => il.DefineLabel());
il = new InstructionEncoder(codeBuilder, new ControlFlowBuilder());
il.DefineLabel();
il.DefineLabel();
var l2 = il.DefineLabel();
var flowBuilder = new ControlFlowBuilder();
il = new InstructionEncoder(codeBuilder, flowBuilder);
var l0 = il.DefineLabel();
Assert.Throws<ArgumentException>(() => il.Branch(ILOpCode.Nop, l0));
Assert.Throws<ArgumentNullException>(() => il.Branch(ILOpCode.Br, default(LabelHandle)));
Assert.Throws<ArgumentException>(() => il.Branch(ILOpCode.Br, l2));
}
public void Branches1()
{
var flowBuilder = new ControlFlowBuilder();
var l0 = flowBuilder.AddLabel();
var l64 = flowBuilder.AddLabel();
var l255 = flowBuilder.AddLabel();
flowBuilder.MarkLabel(0, l0);
flowBuilder.MarkLabel(64, l64);
flowBuilder.MarkLabel(255, l255);
flowBuilder.AddBranch(0, l255, ILOpCode.Bge);
flowBuilder.AddBranch(16, l0, ILOpCode.Bge_un_s); // blob boundary
flowBuilder.AddBranch(33, l255, ILOpCode.Ble); // blob boundary
flowBuilder.AddBranch(38, l0, ILOpCode.Ble_un_s); // branches immediately next to each other
flowBuilder.AddBranch(40, l255, ILOpCode.Blt); // branches immediately next to each other
flowBuilder.AddBranch(46, l64, ILOpCode.Blt_un_s);
flowBuilder.AddBranch(254, l0, ILOpCode.Brfalse); // long branch at the end
var dstBuilder = new BlobBuilder();
var srcBuilder = new BlobBuilder(capacity: 17);
WriteFakeILWithBranches(srcBuilder, flowBuilder, size: 259);
flowBuilder.CopyCodeAndFixupBranches(srcBuilder, dstBuilder);
AssertEx.Equal(new byte[]
{
(byte)ILOpCode.Bge, 0xFA, 0x00, 0x00, 0x00,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
(byte)ILOpCode.Bge_un_s, 0xEE,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
(byte)ILOpCode.Ble, 0xD9, 0x00, 0x00, 0x00,
(byte)ILOpCode.Ble_un_s, 0xD8,
(byte)ILOpCode.Blt, 0xD2, 0x00, 0x00, 0x00,
0x01,
(byte)ILOpCode.Blt_un_s, 0x10,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
(byte)ILOpCode.Brfalse, 0xFD, 0xFE, 0xFF, 0xFF,
}, dstBuilder.ToArray());
}
public void AddFinallyFaultFilterRegions()
{
var code = new BlobBuilder();
var flow = new ControlFlowBuilder();
var il = new InstructionEncoder(code, flow);
var l1 = il.DefineLabel();
var l2 = il.DefineLabel();
var l3 = il.DefineLabel();
var l4 = il.DefineLabel();
var l5 = il.DefineLabel();
il.MarkLabel(l1);
Assert.Equal(0, il.Offset);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l2);
Assert.Equal(1, il.Offset);
il.OpCode(ILOpCode.Nop);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l3);
Assert.Equal(3, il.Offset);
il.OpCode(ILOpCode.Nop);
il.OpCode(ILOpCode.Nop);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l4);
Assert.Equal(6, il.Offset);
il.OpCode(ILOpCode.Nop);
il.OpCode(ILOpCode.Nop);
il.OpCode(ILOpCode.Nop);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l5);
Assert.Equal(10, il.Offset);
flow.AddFaultRegion(l1, l2, l3, l4);
flow.AddFinallyRegion(l1, l2, l3, l4);
flow.AddFilterRegion(l1, l2, l3, l4, l5);
var builder = new BlobBuilder();
builder.WriteByte(0xff);
flow.SerializeExceptionTable(builder);
AssertEx.Equal(new byte[]
{
0xFF, 0x00, 0x00, 0x00, // padding
0x01, // flag
(byte)(builder.Count - 4), // size
0x00, 0x00, // reserved
0x04, 0x00, // kind
0x00, 0x00, // try offset
0x01, // try length
0x03, 0x00, // handler offset
0x03, // handler length
0x00, 0x00, 0x00, 0x00, // catch type or filter offset
0x02, 0x00, // kind
0x00, 0x00, // try offset
0x01, // try length
0x03, 0x00, // handler offset
0x03, // handler length
0x00, 0x00, 0x00, 0x00, // catch type or filter offset
0x01, 0x00, // kind
0x00, 0x00, // try offset
0x01, // try length
0x03, 0x00, // handler offset
0x03, // handler length
0x0A, 0x00, 0x00, 0x00 // catch type or filter offset
}, builder.ToArray());
}
static Location?TryGetLocation([NotNull] ICSharpTreeNode element, [NotNull] ElementProblemAnalyzerData data)
{
switch (element.GetContainingFunctionLikeDeclarationOrClosure())
{
case IAccessorDeclaration accessorDeclaration:
switch (accessorDeclaration.Kind)
{
case AccessorKind.GETTER:
switch (accessorDeclaration.Parent)
{
case IPropertyDeclaration _:
return(Location.PropertyGetter);
case IIndexerDeclaration _:
return(Location.IndexerGetter);
}
break;
case AccessorKind.ADDER:
case AccessorKind.REMOVER:
return(Location.EventAccessor);
}
break;
case IPropertyDeclaration _:
return(Location.PropertyGetter);
case IIndexerDeclaration _:
return(Location.IndexerGetter);
case IMethodDeclaration methodDeclaration when methodDeclaration.DeclaredElement != null:
var psiModule = element.GetPsiModule();
var objectClass = TypeElementUtil.GetTypeElementByClrName(PredefinedType.OBJECT_FQN, psiModule).AssertNotNull();
if (methodDeclaration.DeclaredElement.OverridesOrImplements(GetMethod(objectClass, nameof(object.Equals))))
{
return(Location.EqualsMethod);
}
if (methodDeclaration.DeclaredElement.OverridesOrImplements(GetMethod(objectClass, nameof(GetHashCode))))
{
return(Location.GetHashCodeMethod);
}
if (methodDeclaration.DeclaredElement.OverridesOrImplements(GetMethod(objectClass, nameof(ToString))))
{
return(Location.ToStringMethod);
}
if (methodDeclaration.DeclaredElement.OverridesOrImplements(
GetMethod(
TypeElementUtil.GetTypeElementByClrName(PredefinedType.GENERIC_IEQUATABLE_FQN, psiModule).AssertNotNull(),
nameof(IEquatable <int> .Equals))))
{
return(Location.EqualsMethod);
}
var equalityComparerGenericInterface = TypeElementUtil.GetTypeElementByClrName(ClrTypeNames.IEqualityComparerGeneric, psiModule)
.AssertNotNull();
if (methodDeclaration.DeclaredElement.OverridesOrImplements(
GetMethod(equalityComparerGenericInterface, nameof(IEqualityComparer <int> .Equals))))
{
return(Location.EqualsMethodWithParameters);
}
if (methodDeclaration.DeclaredElement.OverridesOrImplements(
GetMethod(equalityComparerGenericInterface, nameof(IEqualityComparer <int> .GetHashCode))))
{
return(Location.GetHashCodeMethodWithParameter);
}
var equalityComparerInterface =
TypeElementUtil.GetTypeElementByClrName(ClrTypeNames.IEqualityComparer, psiModule).AssertNotNull();
if (methodDeclaration.DeclaredElement.OverridesOrImplements(
GetMethod(equalityComparerInterface, nameof(IEqualityComparer.Equals))))
{
return(Location.EqualsMethodWithParameters);
}
if (methodDeclaration.DeclaredElement.OverridesOrImplements(
GetMethod(equalityComparerInterface, nameof(IEqualityComparer.GetHashCode))))
{
return(Location.GetHashCodeMethodWithParameter);
}
if (methodDeclaration.DeclaredElement.OverridesOrImplements(
GetMethod(
TypeElementUtil.GetTypeElementByClrName(PredefinedType.IDISPOSABLE_FQN, psiModule).AssertNotNull(),
nameof(IDisposable.Dispose))))
{
return(Location.DisposeMethod);
}
if (methodDeclaration.DeclaredElement.ShortName == disposeMethodName && methodDeclaration.DeclaredElement.Parameters.Count == 1)
{
var parameter = methodDeclaration.DeclaredElement.Parameters[0];
if (parameter != null && parameter.Type.IsBool())
{
var controlFlowGraph = (ICSharpControlFlowGraph)ControlFlowBuilder.GetGraph(methodDeclaration);
var controlFlowEdge = controlFlowGraph?.ReachableExits.FirstOrDefault(
e => e?.Type == ControlFlowEdgeType.THROW && e.Source.SourceElement == element);
if (controlFlowEdge != null)
{
var inspector = CSharpControlFlowGraphInspector.Inspect(controlFlowGraph, data.GetValueAnalysisMode());
var controlFlowContext = inspector.GetContext(controlFlowEdge);
var variableInfo = inspector.FindVariableInfo(parameter);
if (variableInfo != null)
{
var variableValue = controlFlowContext?.GetVariableDefiniteState(variableInfo);
if (variableValue == null || variableValue == CSharpControlFlowVariableValue.FALSE)
{
return(Location.DisposeMethodWithParameterFalseCodePath);
}
}
}
}
}
break;
case IConstructorDeclaration constructorDeclaration when constructorDeclaration.IsStatic:
return(Location.StaticConstructor);
case IDestructorDeclaration _:
return(Location.Finalizer);
case ISignOperatorDeclaration signOperator:
var tokenType = signOperator.OperatorSign?.GetTokenType();
if (tokenType == CSharpTokenType.EQEQ || tokenType == CSharpTokenType.NE)
{
return(Location.EqualityOperator);
}
break;
case IConversionOperatorDeclaration conversionOperatorDeclaration
when conversionOperatorDeclaration.Modifier?.GetTokenType() == CSharpTokenType.IMPLICIT_KEYWORD:
return(Location.ImplicitCastOperator);
}
return(null);
}
public void AddCatchRegions()
{
var code = new BlobBuilder();
var flow = new ControlFlowBuilder();
var il = new InstructionEncoder(code, flow);
var l1 = il.DefineLabel();
var l2 = il.DefineLabel();
var l3 = il.DefineLabel();
var l4 = il.DefineLabel();
var l5 = il.DefineLabel();
il.MarkLabel(l1);
Assert.Equal(0, il.Offset);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l2);
Assert.Equal(1, il.Offset);
il.OpCode(ILOpCode.Nop);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l3);
Assert.Equal(3, il.Offset);
il.OpCode(ILOpCode.Nop);
il.OpCode(ILOpCode.Nop);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l4);
Assert.Equal(6, il.Offset);
il.OpCode(ILOpCode.Nop);
il.OpCode(ILOpCode.Nop);
il.OpCode(ILOpCode.Nop);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l5);
Assert.Equal(10, il.Offset);
flow.AddCatchRegion(l1, l2, l3, l4, MetadataTokens.TypeDefinitionHandle(1));
flow.AddCatchRegion(l1, l2, l3, l4, MetadataTokens.TypeSpecificationHandle(2));
flow.AddCatchRegion(l1, l2, l3, l4, MetadataTokens.TypeReferenceHandle(3));
var builder = new BlobBuilder();
flow.SerializeExceptionTable(builder);
AssertEx.Equal(new byte[]
{
0x01, // flag
(byte)builder.Count, // size
0x00, 0x00, // reserved
0x00, 0x00, // kind
0x00, 0x00, // try offset
0x01, // try length
0x03, 0x00, // handler offset
0x03, // handler length
0x01, 0x00, 0x00, 0x02, // catch type or filter offset
0x00, 0x00, // kind
0x00, 0x00, // try offset
0x01, // try length
0x03, 0x00, // handler offset
0x03, // handler length
0x02, 0x00, 0x00, 0x1B, // catch type or filter offset
0x00, 0x00, // kind
0x00, 0x00, // try offset
0x01, // try length
0x03, 0x00, // handler offset
0x03, // handler length
0x03, 0x00, 0x00, 0x01, // catch type or filter offset
}, builder.ToArray());
}
public void AddFinallyFaultFilterRegions()
{
var code = new BlobBuilder();
var flow = new ControlFlowBuilder();
var il = new InstructionEncoder(code, flow);
var l1 = il.DefineLabel();
var l2 = il.DefineLabel();
var l3 = il.DefineLabel();
var l4 = il.DefineLabel();
var l5 = il.DefineLabel();
il.MarkLabel(l1);
Assert.Equal(0, il.Offset);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l2);
Assert.Equal(1, il.Offset);
il.OpCode(ILOpCode.Nop);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l3);
Assert.Equal(3, il.Offset);
il.OpCode(ILOpCode.Nop);
il.OpCode(ILOpCode.Nop);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l4);
Assert.Equal(6, il.Offset);
il.OpCode(ILOpCode.Nop);
il.OpCode(ILOpCode.Nop);
il.OpCode(ILOpCode.Nop);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l5);
Assert.Equal(10, il.Offset);
flow.AddFaultRegion(l1, l2, l3, l4);
flow.AddFinallyRegion(l1, l2, l3, l4);
flow.AddFilterRegion(l1, l2, l3, l4, l5);
var builder = new BlobBuilder();
builder.WriteByte(0xff);
flow.SerializeExceptionTable(builder);
AssertEx.Equal(new byte[]
{
0xFF, 0x00, 0x00, 0x00, // padding
0x01, // flag
(byte)(builder.Count - 4), // size
0x00, 0x00, // reserved
0x04, 0x00, // kind
0x00, 0x00, // try offset
0x01, // try length
0x03, 0x00, // handler offset
0x03, // handler length
0x00, 0x00, 0x00, 0x00, // catch type or filter offset
0x02, 0x00, // kind
0x00, 0x00, // try offset
0x01, // try length
0x03, 0x00, // handler offset
0x03, // handler length
0x00, 0x00, 0x00, 0x00, // catch type or filter offset
0x01, 0x00, // kind
0x00, 0x00, // try offset
0x01, // try length
0x03, 0x00, // handler offset
0x03, // handler length
0x0A, 0x00, 0x00, 0x00 // catch type or filter offset
}, builder.ToArray());
}
public void AddCatchRegions()
{
var code = new BlobBuilder();
var flow = new ControlFlowBuilder();
var il = new InstructionEncoder(code, flow);
var l1 = il.DefineLabel();
var l2 = il.DefineLabel();
var l3 = il.DefineLabel();
var l4 = il.DefineLabel();
var l5 = il.DefineLabel();
il.MarkLabel(l1);
Assert.Equal(0, il.Offset);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l2);
Assert.Equal(1, il.Offset);
il.OpCode(ILOpCode.Nop);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l3);
Assert.Equal(3, il.Offset);
il.OpCode(ILOpCode.Nop);
il.OpCode(ILOpCode.Nop);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l4);
Assert.Equal(6, il.Offset);
il.OpCode(ILOpCode.Nop);
il.OpCode(ILOpCode.Nop);
il.OpCode(ILOpCode.Nop);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l5);
Assert.Equal(10, il.Offset);
flow.AddCatchRegion(l1, l2, l3, l4, MetadataTokens.TypeDefinitionHandle(1));
flow.AddCatchRegion(l1, l2, l3, l4, MetadataTokens.TypeSpecificationHandle(2));
flow.AddCatchRegion(l1, l2, l3, l4, MetadataTokens.TypeReferenceHandle(3));
var builder = new BlobBuilder();
flow.SerializeExceptionTable(builder);
AssertEx.Equal(new byte[]
{
0x01, // flag
(byte)builder.Count, // size
0x00, 0x00, // reserved
0x00, 0x00, // kind
0x00, 0x00, // try offset
0x01, // try length
0x03, 0x00, // handler offset
0x03, // handler length
0x01, 0x00, 0x00, 0x02, // catch type or filter offset
0x00, 0x00, // kind
0x00, 0x00, // try offset
0x01, // try length
0x03, 0x00, // handler offset
0x03, // handler length
0x02, 0x00, 0x00, 0x1B, // catch type or filter offset
0x00, 0x00, // kind
0x00, 0x00, // try offset
0x01, // try length
0x03, 0x00, // handler offset
0x03, // handler length
0x03, 0x00, 0x00, 0x01, // catch type or filter offset
}, builder.ToArray());
}
public unsafe void FatBody()
{
var streamBuilder = new BlobBuilder();
var codeBuilder = new BlobBuilder();
var flowBuilder = new ControlFlowBuilder();
var il = new InstructionEncoder(codeBuilder, flowBuilder);
codeBuilder.WriteBytes(1, 62);
var l1 = il.DefineLabel();
il.MarkLabel(l1);
Assert.Equal(62, flowBuilder.Labels.Single());
il.Branch(ILOpCode.Br_s, l1);
var brInfo = flowBuilder.Branches.Single();
Assert.Equal(62, brInfo.ILOffset);
Assert.Equal(l1, brInfo.Label);
Assert.Equal(ILOpCode.Br_s, brInfo.OpCode);
AssertEx.Equal(new byte[] { 1, 1, (byte)ILOpCode.Br_s, unchecked((byte)-1) }, codeBuilder.ToArray(60, 4));
var streamEncoder = new MethodBodyStreamEncoder(streamBuilder);
int bodyOffset = streamEncoder.AddMethodBody(
il,
maxStack: 2,
localVariablesSignature: default(StandaloneSignatureHandle),
attributes: MethodBodyAttributes.None);
var bodyBytes = streamBuilder.ToArray();
AssertEx.Equal(new byte[]
{
0x03, 0x30, 0x02, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // fat header
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x2B, 0xFE
}, bodyBytes);
fixed (byte* bodyPtr = &bodyBytes[0])
{
var body = MethodBodyBlock.Create(new BlobReader(bodyPtr, bodyBytes.Length));
Assert.Equal(0, body.ExceptionRegions.Length);
Assert.Equal(default(StandaloneSignatureHandle), body.LocalSignature);
Assert.Equal(2, body.MaxStack);
Assert.Equal(bodyBytes.Length, body.Size);
var ilBytes = body.GetILBytes();
AssertEx.Equal(new byte[]
{
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x2B, 0xFE
}, ilBytes);
}
}
private static MethodDefinitionHandle EmitHelloWorld(MetadataBuilder metadata, BlobBuilder ilBuilder)
{
// Create module and assembly for a console application.
metadata.AddModule(
0,
metadata.GetOrAddString("ConsoleApplication.exe"),
metadata.GetOrAddGuid(s_guid),
default(GuidHandle),
default(GuidHandle));
metadata.AddAssembly(
metadata.GetOrAddString("ConsoleApplication"),
version: new Version(1, 0, 0, 0),
culture: default(StringHandle),
publicKey: default(BlobHandle),
flags: 0,
hashAlgorithm: AssemblyHashAlgorithm.None);
// Create references to System.Object and System.Console types.
AssemblyReferenceHandle mscorlibAssemblyRef = metadata.AddAssemblyReference(
name: metadata.GetOrAddString("mscorlib"),
version: new Version(4, 0, 0, 0),
culture: default(StringHandle),
publicKeyOrToken: metadata.GetOrAddBlob(
new byte[] { 0xB7, 0x7A, 0x5C, 0x56, 0x19, 0x34, 0xE0, 0x89 }
),
flags: default(AssemblyFlags),
hashValue: default(BlobHandle));
TypeReferenceHandle systemObjectTypeRef = metadata.AddTypeReference(
mscorlibAssemblyRef,
metadata.GetOrAddString("System"),
metadata.GetOrAddString("Object"));
TypeReferenceHandle systemConsoleTypeRefHandle = metadata.AddTypeReference(
mscorlibAssemblyRef,
metadata.GetOrAddString("System"),
metadata.GetOrAddString("Console"));
// Get reference to Console.WriteLine(string) method.
var consoleWriteLineSignature = new BlobBuilder();
new BlobEncoder(consoleWriteLineSignature).
MethodSignature().
Parameters(1,
returnType => returnType.Void(),
parameters => parameters.AddParameter().Type().String());
MemberReferenceHandle consoleWriteLineMemberRef = metadata.AddMemberReference(
systemConsoleTypeRefHandle,
metadata.GetOrAddString("WriteLine"),
metadata.GetOrAddBlob(consoleWriteLineSignature));
// Get reference to Object's constructor.
var parameterlessCtorSignature = new BlobBuilder();
new BlobEncoder(parameterlessCtorSignature).
MethodSignature(isInstanceMethod: true).
Parameters(0, returnType => returnType.Void(), parameters => { });
BlobHandle parameterlessCtorBlobIndex = metadata.GetOrAddBlob(parameterlessCtorSignature);
MemberReferenceHandle objectCtorMemberRef = metadata.AddMemberReference(
systemObjectTypeRef,
metadata.GetOrAddString(".ctor"),
parameterlessCtorBlobIndex);
// Create signature for "void Main()" method.
var mainSignature = new BlobBuilder();
new BlobEncoder(mainSignature).
MethodSignature().
Parameters(0, returnType => returnType.Void(), parameters => { });
var methodBodyStream = new MethodBodyStreamEncoder(ilBuilder);
var codeBuilder = new BlobBuilder();
InstructionEncoder il;
// Emit IL for Program::.ctor
il = new InstructionEncoder(codeBuilder);
// ldarg.0
il.LoadArgument(0);
// call instance void [mscorlib]System.Object::.ctor()
il.Call(objectCtorMemberRef);
// ret
il.OpCode(ILOpCode.Ret);
int ctorBodyOffset = methodBodyStream.AddMethodBody(il);
codeBuilder.Clear();
// Emit IL for Program::Main
var flowBuilder = new ControlFlowBuilder();
il = new InstructionEncoder(codeBuilder, flowBuilder);
// ldstr "hello"
il.LoadString(metadata.GetOrAddUserString("Hello, world"));
// call void [mscorlib]System.Console::WriteLine(string)
il.Call(consoleWriteLineMemberRef);
// ret
il.OpCode(ILOpCode.Ret);
int mainBodyOffset = methodBodyStream.AddMethodBody(il);
codeBuilder.Clear();
// Create method definition for Program::Main
MethodDefinitionHandle mainMethodDef = metadata.AddMethodDefinition(
MethodAttributes.Public | MethodAttributes.Static | MethodAttributes.HideBySig,
MethodImplAttributes.IL,
metadata.GetOrAddString("Main"),
metadata.GetOrAddBlob(mainSignature),
mainBodyOffset,
parameterList: default(ParameterHandle));
// Create method definition for Program::.ctor
MethodDefinitionHandle ctorDef = metadata.AddMethodDefinition(
MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName,
MethodImplAttributes.IL,
metadata.GetOrAddString(".ctor"),
parameterlessCtorBlobIndex,
ctorBodyOffset,
parameterList: default(ParameterHandle));
// Create type definition for the special <Module> type that holds global functions
metadata.AddTypeDefinition(
default(TypeAttributes),
default(StringHandle),
metadata.GetOrAddString("<Module>"),
baseType: default(EntityHandle),
fieldList: MetadataTokens.FieldDefinitionHandle(1),
methodList: mainMethodDef);
// Create type definition for ConsoleApplication.Program
metadata.AddTypeDefinition(
TypeAttributes.Class | TypeAttributes.Public | TypeAttributes.AutoLayout | TypeAttributes.BeforeFieldInit,
metadata.GetOrAddString("ConsoleApplication"),
metadata.GetOrAddString("Program"),
baseType: systemObjectTypeRef,
fieldList: MetadataTokens.FieldDefinitionHandle(1),
methodList: mainMethodDef);
return(mainMethodDef);
}
