We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

The Labs \ Source Viewer \ SSCLI \ System.Reflection.Emit \ __FixupData

SSCLI

// ==++==
//
//
//
// The use and distribution terms for this software are contained in the file
// named license.txt, which can be found in the root of this distribution.
// By using this software in any fashion, you are agreeing to be bound by the
// terms of this license.
//
// You must not remove this notice, or any other, from this software.
//
//
// ==--==
namespace System.Reflection.Emit
{
using System;
using TextWriter = System.IO.TextWriter;
using System.Diagnostics.SymbolStore;
using System.Runtime.InteropServices;
using System.Reflection;
using System.Security.Permissions;
using System.Globalization;
[ClassInterface(ClassInterfaceType.None)]
[ComDefaultInterface(typeof(_ILGenerator))]
[System.Runtime.InteropServices.ComVisible(true)]
public class ILGenerator : _ILGenerator
{
#region Const Members
internal const byte PrefixInstruction = (byte)255;
internal const int defaultSize = 16;
internal const int DefaultFixupArraySize = 64;
internal const int DefaultLabelArraySize = 16;
internal const int DefaultExceptionArraySize = 8;
#endregion
#region Internal Statics
static internal int[] EnlargeArray(int[] incoming)
{
int[] temp = new int[incoming.Length * 2];
Array.Copy(incoming, temp, incoming.Length);
return temp;
}
static internal byte[] EnlargeArray(byte[] incoming)
{
byte[] temp = new byte[incoming.Length * 2];
Array.Copy(incoming, temp, incoming.Length);
return temp;
}
static internal byte[] EnlargeArray(byte[] incoming, int requiredSize)
{
byte[] temp = new byte[requiredSize];
Array.Copy(incoming, temp, incoming.Length);
return temp;
}
static internal __FixupData[] EnlargeArray(__FixupData[] incoming)
{
__FixupData[] temp = new __FixupData[incoming.Length * 2];
//Does arraycopy work for value classes?
Array.Copy(incoming, temp, incoming.Length);
return temp;
}
static internal Type[] EnlargeArray(Type[] incoming)
{
Type[] temp = new Type[incoming.Length * 2];
Array.Copy(incoming, temp, incoming.Length);
return temp;
}
static internal __ExceptionInfo[] EnlargeArray(__ExceptionInfo[] incoming)
{
__ExceptionInfo[] temp = new __ExceptionInfo[incoming.Length * 2];
Array.Copy(incoming, temp, incoming.Length);
return temp;
}
static internal int CalculateNumberOfExceptions(__ExceptionInfo[] excp)
{
int num = 0;
if (excp == null)
return 0;
for (int i = 0; i < excp.Length; i++)
num += excp[i].GetNumberOfCatches();
return num;
}
#endregion
#region Internal Data Members
internal int m_length;
internal byte[] m_ILStream;
internal int[] m_labelList;
internal int m_labelCount;
internal __FixupData[] m_fixupData;
//internal Label[] m_fixupLabel;
//internal int[] m_fixupPos;
internal int m_fixupCount;
internal int[] m_RVAFixupList;
internal int m_RVAFixupCount;
internal int[] m_RelocFixupList;
internal int m_RelocFixupCount;
internal int m_exceptionCount;
internal int m_currExcStackCount;
internal __ExceptionInfo[] m_exceptions;
//This is the list of all of the exceptions in this ILStream.
internal __ExceptionInfo[] m_currExcStack;
//This is the stack of exceptions which we're currently in.
internal ScopeTree m_ScopeTree;
// this variable tracks all debugging scope information
internal LineNumberInfo m_LineNumberInfo;
// this variable tracks all line number information
internal MethodInfo m_methodBuilder;
internal int m_localCount;
internal SignatureHelper m_localSignature;
internal int m_maxStackSize = 0;
// Maximum stack size not counting the exceptions.
internal int m_maxMidStack = 0;
// Maximum stack size for a given basic block.
internal int m_maxMidStackCur = 0;
// Running count of the maximum stack size for the current basic block.
#endregion
#region Constructor
// package private constructor. This code path is used when client create
// ILGenerator through MethodBuilder.
internal ILGenerator(MethodInfo methodBuilder) : this(methodBuilder, 64)
{
}
internal ILGenerator(MethodInfo methodBuilder, int size)
{
if (size < defaultSize) {
m_ILStream = new byte[defaultSize];
}
else {
m_ILStream = new byte[size];
}
m_length = 0;
m_labelCount = 0;
m_fixupCount = 0;
m_labelList = null;
m_fixupData = null;
m_exceptions = null;
m_exceptionCount = 0;
m_currExcStack = null;
m_currExcStackCount = 0;
m_RelocFixupList = new int[DefaultFixupArraySize];
m_RelocFixupCount = 0;
m_RVAFixupList = new int[DefaultFixupArraySize];
m_RVAFixupCount = 0;
// initialize the scope tree
m_ScopeTree = new ScopeTree();
m_LineNumberInfo = new LineNumberInfo();
m_methodBuilder = methodBuilder;
// initialize local signature
m_localCount = 0;
MethodBuilder mb = m_methodBuilder as MethodBuilder;
if (mb == null)
m_localSignature = SignatureHelper.GetLocalVarSigHelper(null);
else
m_localSignature = SignatureHelper.GetLocalVarSigHelper(mb.GetTypeBuilder().Module);
}
internal ILGenerator(int size)
{
if (size < defaultSize)
m_ILStream = new byte[defaultSize];
else
m_ILStream = new byte[size];
m_length = 0;
m_labelCount = 0;
m_fixupCount = 0;
m_labelList = null;
m_fixupData = null;
m_exceptions = null;
m_exceptionCount = 0;
m_currExcStack = null;
m_currExcStackCount = 0;
m_RelocFixupList = new int[DefaultFixupArraySize];
m_RelocFixupCount = 0;
m_RVAFixupList = new int[DefaultFixupArraySize];
m_RVAFixupCount = 0;
// initialize the scope tree
m_ScopeTree = new ScopeTree();
m_LineNumberInfo = new LineNumberInfo();
m_methodBuilder = null;
// initialize local signature
m_localCount = 0;
m_localSignature = SignatureHelper.GetLocalVarSigHelper(null);
}
#endregion
#region Private Members
private void RecordTokenFixup()
{
if (m_RelocFixupCount >= m_RelocFixupList.Length)
m_RelocFixupList = EnlargeArray(m_RelocFixupList);
m_RelocFixupList[m_RelocFixupCount++] = m_length;
}
#endregion
#region Internal Members
internal void InternalEmit(OpCode opcode)
{
if (opcode.m_size == 1) {
m_ILStream[m_length++] = opcode.m_s2;
}
else {
m_ILStream[m_length++] = opcode.m_s1;
m_ILStream[m_length++] = opcode.m_s2;
}
UpdateStackSize(opcode, opcode.StackChange());
}
internal void UpdateStackSize(OpCode opcode, int stackchange)
{
// Updates internal variables for keeping track of the stack size
// requirements for the function. stackchange specifies the amount
// by which the stacksize needs to be updated.
// Special case for the Return. Returns pops 1 if there is a
// non-void return value.
// Update the running stacksize. m_maxMidStack specifies the maximum
// amount of stack required for the current basic block irrespective of
// where you enter the block.
m_maxMidStackCur += stackchange;
if (m_maxMidStackCur > m_maxMidStack)
m_maxMidStack = m_maxMidStackCur;
else if (m_maxMidStackCur < 0)
m_maxMidStackCur = 0;
// If the current instruction signifies end of a basic, which basically
// means an unconditional branch, add m_maxMidStack to m_maxStackSize.
// m_maxStackSize will eventually be the sum of the stack requirements for
// each basic block.
if (opcode.EndsUncondJmpBlk()) {
m_maxStackSize += m_maxMidStack;
m_maxMidStack = 0;
m_maxMidStackCur = 0;
}
}
internal virtual int GetMethodToken(MethodBase method, Type[] optionalParameterTypes)
{
int tk = 0;
ModuleBuilder modBuilder = (ModuleBuilder)m_methodBuilder.Module;
if (method.IsGenericMethod) {
// Given M<Bar> unbind to M<S>
MethodInfo methodInfoUnbound = method as MethodInfo;
if (!method.IsGenericMethodDefinition && method is MethodInfo)
methodInfoUnbound = ((MethodInfo)method).GetGenericMethodDefinition();
if (methodInfoUnbound.Module != m_methodBuilder.Module || (methodInfoUnbound.DeclaringType != null && methodInfoUnbound.DeclaringType.IsGenericType))
tk = GetMemberRefToken(methodInfoUnbound, null);
else
tk = modBuilder.GetMethodToken(methodInfoUnbound).Token;
// Create signature of method instantiation M<Bar>
int sigLength;
byte[] sigBytes = SignatureHelper.GetMethodSpecSigHelper(modBuilder, method.GetGenericArguments()).InternalGetSignature(out sigLength);
// Create MethodSepc M<Bar> with parent G?.M<S>
tk = TypeBuilder.InternalDefineMethodSpec(tk, sigBytes, sigLength, modBuilder);
}
else {
if (((method.CallingConvention & CallingConventions.VarArgs) == 0) && (method.DeclaringType == null || !method.DeclaringType.IsGenericType)) {
if (method is MethodInfo)
tk = modBuilder.GetMethodToken(method as MethodInfo).Token;
else
tk = modBuilder.GetConstructorToken(method as ConstructorInfo).Token;
}
else {
tk = GetMemberRefToken(method, optionalParameterTypes);
}
}
return tk;
}
internal virtual int GetMemberRefToken(MethodBase method, Type[] optionalParameterTypes)
{
Type[] parameterTypes;
Type returnType;
int tkParent;
ModuleBuilder modBuilder = (ModuleBuilder)m_methodBuilder.Module;
int cGenericParameters = 0;
if (method.IsGenericMethod) {
if (!method.IsGenericMethodDefinition)
throw new InvalidOperationException();
cGenericParameters = method.GetGenericArguments().Length;
}
if (optionalParameterTypes != null) {
if ((method.CallingConvention & CallingConventions.VarArgs) == 0) {
// Client should not supply optional parameter in default calling convention
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NotAVarArgCallingConvention"));
}
}
if (method.DeclaringType.IsGenericType) {
MethodBase methDef = null;
// methodInfo = G<Foo>.M<Bar> ==> methDef = G<T>.M<S>
if (method is MethodOnTypeBuilderInstantiation) {
methDef = (method as MethodOnTypeBuilderInstantiation).m_method;
}
else if (method is ConstructorOnTypeBuilderInstantiation) {
methDef = (method as ConstructorOnTypeBuilderInstantiation).m_ctor;
}
else if (method is MethodBuilder || method is ConstructorBuilder) {
// methodInfo must be GenericMethodDefinition; trying to emit G<?>.M<S>
methDef = method;
}
else if (method.IsGenericMethod) {
methDef = ((MethodInfo)method).GetGenericMethodDefinition();
methDef = methDef.Module.ResolveMethod(methDef.MetadataTokenInternal, methDef.GetGenericArguments(), methDef.DeclaringType != null ? methDef.DeclaringType.GetGenericArguments() : null) as MethodBase;
}
else {
methDef = method;
methDef = method.Module.ResolveMethod(method.MetadataTokenInternal, null, methDef.DeclaringType != null ? methDef.DeclaringType.GetGenericArguments() : null) as MethodBase;
}
parameterTypes = methDef.GetParameterTypes();
returnType = methDef.GetReturnType();
}
else {
parameterTypes = method.GetParameterTypes();
returnType = method.GetReturnType();
}
if (method.DeclaringType.IsGenericType) {
int length;
byte[] sig = SignatureHelper.GetTypeSigToken(modBuilder, method.DeclaringType).InternalGetSignature(out length);
tkParent = modBuilder.InternalGetTypeSpecTokenWithBytes(sig, length);
}
else if (method.Module != modBuilder) {
// Use typeRef as parent because the method's declaringType lives in a different assembly
tkParent = modBuilder.GetTypeToken(method.DeclaringType).Token;
}
else {
// Use methodDef as parent because the method lives in this assembly and its declaringType has no generic arguments
if (method is MethodInfo)
tkParent = modBuilder.GetMethodToken(method as MethodInfo).Token;
else
tkParent = modBuilder.GetConstructorToken(method as ConstructorInfo).Token;
}
int sigLength;
byte[] sigBytes = GetMemberRefSignature(method.CallingConvention, returnType, parameterTypes, optionalParameterTypes, cGenericParameters).InternalGetSignature(out sigLength);
return modBuilder.InternalGetMemberRefFromSignature(tkParent, method.Name, sigBytes, sigLength);
}
internal virtual SignatureHelper GetMemberRefSignature(CallingConventions call, Type returnType, Type[] parameterTypes, Type[] optionalParameterTypes)
{
return GetMemberRefSignature(call, returnType, parameterTypes, optionalParameterTypes, 0);
}
internal virtual SignatureHelper GetMemberRefSignature(CallingConventions call, Type returnType, Type[] parameterTypes, Type[] optionalParameterTypes, int cGenericParameters)
{
int cParams;
int i;
SignatureHelper sig;
if (parameterTypes == null) {
cParams = 0;
}
else {
cParams = parameterTypes.Length;
}
sig = SignatureHelper.GetMethodSigHelper(m_methodBuilder.Module, call, returnType, cGenericParameters);
for (i = 0; i < cParams; i++)
sig.AddArgument(parameterTypes[i]);
if (optionalParameterTypes != null && optionalParameterTypes.Length != 0) {
// add the sentinel
sig.AddSentinel();
for (i = 0; i < optionalParameterTypes.Length; i++)
sig.AddArgument(optionalParameterTypes[i]);
}
return sig;
}
internal virtual byte[] BakeByteArray()
{
// BakeByteArray is a package private function designed to be called by MethodDefinition to do
// all of the fixups and return a new byte array representing the byte stream with labels resolved, etc.
//
int newSize;
int updateAddr;
byte[] newBytes;
if (m_currExcStackCount != 0) {
throw new ArgumentException(Environment.GetResourceString("Argument_UnclosedExceptionBlock"));
}
if (m_length == 0)
return null;
//Calculate the size of the new array.
newSize = m_length;
//Allocate space for the new array.
newBytes = new byte[newSize];
//Copy the data from the old array
Array.Copy(m_ILStream, newBytes, newSize);
//Do the fixups.
//This involves iterating over all of the labels and
//replacing them with their proper values.
for (int i = 0; i < m_fixupCount; i++) {
updateAddr = GetLabelPos(m_fixupData[i].m_fixupLabel) - (m_fixupData[i].m_fixupPos + m_fixupData[i].m_fixupInstSize);
//Handle single byte instructions
//Throw an exception if they're trying to store a jump in a single byte instruction that doesn't fit.
if (m_fixupData[i].m_fixupInstSize == 1) {
//Verify that our one-byte arg will fit into a Signed Byte.
if (updateAddr < SByte.MinValue || updateAddr > SByte.MaxValue) {
throw new NotSupportedException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("NotSupported_IllegalOneByteBranch"), m_fixupData[i].m_fixupPos, updateAddr));
}
//Place the one-byte arg
if (updateAddr < 0) {
newBytes[m_fixupData[i].m_fixupPos] = (byte)(256 + updateAddr);
}
else {
newBytes[m_fixupData[i].m_fixupPos] = (byte)updateAddr;
}
}
else {
//Place the four-byte arg
PutInteger4(updateAddr, m_fixupData[i].m_fixupPos, newBytes);
}
}
return newBytes;
}
internal virtual __ExceptionInfo[] GetExceptions()
{
__ExceptionInfo[] temp;
if (m_currExcStackCount != 0) {
throw new NotSupportedException(Environment.GetResourceString(ResId.Argument_UnclosedExceptionBlock));
}
if (m_exceptionCount == 0) {
return null;
}
temp = new __ExceptionInfo[m_exceptionCount];
Array.Copy(m_exceptions, temp, m_exceptionCount);
SortExceptions(temp);
return temp;
}
internal virtual void EnsureCapacity(int size)
{
// Guarantees an array capable of holding at least size elements.
if (m_length + size >= m_ILStream.Length) {
if (m_length + size >= 2 * m_ILStream.Length) {
m_ILStream = EnlargeArray(m_ILStream, m_length + size);
}
else {
m_ILStream = EnlargeArray(m_ILStream);
}
}
}
internal virtual int PutInteger4(int value, int startPos, byte[] array)
{
// Puts an Int32 onto the stream. This is an internal routine, so it does not do any error checking.
array[startPos++] = (byte)value;
array[startPos++] = (byte)(value >> 8);
array[startPos++] = (byte)(value >> 16);
array[startPos++] = (byte)(value >> 24);
return startPos;
}
internal virtual int GetLabelPos(Label lbl)
{
// Gets the position in the stream of a particular label.
// Verifies that the label exists and that it has been given a value.
int index = lbl.GetLabelValue();
if (index < 0 || index >= m_labelCount)
throw new ArgumentException(Environment.GetResourceString("Argument_BadLabel"));
if (m_labelList[index] < 0)
throw new ArgumentException(Environment.GetResourceString("Argument_BadLabelContent"));
return m_labelList[index];
}
internal virtual void AddFixup(Label lbl, int pos, int instSize)
{
// Notes the label, position, and instruction size of a new fixup. Expands
// all of the fixup arrays as appropriate.
if (m_fixupData == null) {
m_fixupData = new __FixupData[DefaultFixupArraySize];
}
if (m_fixupCount >= m_fixupData.Length) {
m_fixupData = EnlargeArray(m_fixupData);
}
m_fixupData[m_fixupCount].m_fixupPos = pos;
m_fixupData[m_fixupCount].m_fixupLabel = lbl;
m_fixupData[m_fixupCount].m_fixupInstSize = instSize;
m_fixupCount++;
}
internal virtual int GetMaxStackSize()
{
MethodBuilder methodBuilder = m_methodBuilder as MethodBuilder;
if (methodBuilder == null)
throw new NotSupportedException();
return m_maxStackSize + methodBuilder.GetNumberOfExceptions();
}
internal virtual void SortExceptions(__ExceptionInfo[] exceptions)
{
int least;
__ExceptionInfo temp;
int length = exceptions.Length;
for (int i = 0; i < length; i++) {
least = i;
for (int j = i + 1; j < length; j++) {
if (exceptions[least].IsInner(exceptions[j])) {
least = j;
}
}
temp = exceptions[i];
exceptions[i] = exceptions[least];
exceptions[least] = temp;
}
}
internal virtual int[] GetTokenFixups()
{
int[] narrowTokens = new int[m_RelocFixupCount];
Array.Copy(m_RelocFixupList, narrowTokens, m_RelocFixupCount);
return narrowTokens;
}
internal virtual int[] GetRVAFixups()
{
int[] narrowRVAs = new int[m_RVAFixupCount];
Array.Copy(m_RVAFixupList, narrowRVAs, m_RVAFixupCount);
return narrowRVAs;
}
#endregion
#region Public Members
#region Emit
public virtual void Emit(OpCode opcode)
{
EnsureCapacity(3);
InternalEmit(opcode);
}
public virtual void Emit(OpCode opcode, byte arg)
{
EnsureCapacity(4);
InternalEmit(opcode);
m_ILStream[m_length++] = arg;
}
[CLSCompliant(false)]
public void Emit(OpCode opcode, sbyte arg)
{
// Puts opcode onto the stream of instructions followed by arg
EnsureCapacity(4);
InternalEmit(opcode);
if (arg < 0) {
m_ILStream[m_length++] = (byte)(256 + arg);
}
else {
m_ILStream[m_length++] = (byte)arg;
}
}
public virtual void Emit(OpCode opcode, short arg)
{
// Puts opcode onto the stream of instructions followed by arg
EnsureCapacity(5);
InternalEmit(opcode);
m_ILStream[m_length++] = (byte)arg;
m_ILStream[m_length++] = (byte)(arg >> 8);
}
public virtual void Emit(OpCode opcode, int arg)
{
// Puts opcode onto the stream of instructions followed by arg
EnsureCapacity(7);
InternalEmit(opcode);
m_length = PutInteger4(arg, m_length, m_ILStream);
}
public virtual void Emit(OpCode opcode, MethodInfo meth)
{
if (opcode.Equals(OpCodes.Call) || opcode.Equals(OpCodes.Callvirt) || opcode.Equals(OpCodes.Newobj)) {
EmitCall(opcode, meth, null);
}
else {
int stackchange = 0;
if (meth == null)
throw new ArgumentNullException("meth");
int tk = GetMethodToken(meth, null);
EnsureCapacity(7);
InternalEmit(opcode);
UpdateStackSize(opcode, stackchange);
RecordTokenFixup();
m_length = PutInteger4(tk, m_length, m_ILStream);
}
}
public virtual void EmitCalli(OpCode opcode, CallingConventions callingConvention, Type returnType, Type[] parameterTypes, Type[] optionalParameterTypes)
{
int stackchange = 0;
SignatureHelper sig;
if (optionalParameterTypes != null) {
if ((callingConvention & CallingConventions.VarArgs) == 0) {
// Client should not supply optional parameter in default calling convention
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NotAVarArgCallingConvention"));
}
}
ModuleBuilder modBuilder = (ModuleBuilder)m_methodBuilder.Module;
sig = GetMemberRefSignature(callingConvention, returnType, parameterTypes, optionalParameterTypes);
EnsureCapacity(7);
Emit(OpCodes.Calli);
// The opcode passed in must be the calli instruction.
BCLDebug.Assert(opcode.Equals(OpCodes.Calli), "Unexpected opcode passed to EmitCalli.");
// If there is a non-void return type, push one.
if (returnType != typeof(void))
stackchange++;
// Pop off arguments if any.
if (parameterTypes != null)
stackchange -= parameterTypes.Length;
// Pop off vararg arguments.
if (optionalParameterTypes != null)
stackchange -= optionalParameterTypes.Length;
// Pop the this parameter if the method has a this parameter.
if ((callingConvention & CallingConventions.HasThis) == CallingConventions.HasThis)
stackchange--;
// Pop the native function pointer.
stackchange--;
UpdateStackSize(opcode, stackchange);
RecordTokenFixup();
m_length = PutInteger4(modBuilder.GetSignatureToken(sig).Token, m_length, m_ILStream);
}
public virtual void EmitCalli(OpCode opcode, CallingConvention unmanagedCallConv, Type returnType, Type[] parameterTypes)
{
int stackchange = 0;
int cParams = 0;
int i;
SignatureHelper sig;
ModuleBuilder modBuilder = (ModuleBuilder)m_methodBuilder.Module;
// The opcode passed in must be the calli instruction.
BCLDebug.Assert(opcode.Equals(OpCodes.Calli), "Unexpected opcode passed to EmitCalli.");
if (parameterTypes != null) {
cParams = parameterTypes.Length;
}
sig = SignatureHelper.GetMethodSigHelper(modBuilder, unmanagedCallConv, returnType);
if (parameterTypes != null) {
for (i = 0; i < cParams; i++) {
sig.AddArgument(parameterTypes[i]);
}
}
// If there is a non-void return type, push one.
if (returnType != typeof(void))
stackchange++;
// Pop off arguments if any.
if (parameterTypes != null)
stackchange -= cParams;
// Pop the native function pointer.
stackchange--;
UpdateStackSize(opcode, stackchange);
EnsureCapacity(7);
Emit(OpCodes.Calli);
RecordTokenFixup();
m_length = PutInteger4(modBuilder.GetSignatureToken(sig).Token, m_length, m_ILStream);
}
public virtual void EmitCall(OpCode opcode, MethodInfo methodInfo, Type[] optionalParameterTypes)
{
int stackchange = 0;
if (methodInfo == null)
throw new ArgumentNullException("methodInfo");
int tk = GetMethodToken(methodInfo, optionalParameterTypes);
EnsureCapacity(7);
InternalEmit(opcode);
// The opcode must be one of call, callvirt, or newobj.
BCLDebug.Assert(opcode.Equals(OpCodes.Call) || opcode.Equals(OpCodes.Callvirt) || opcode.Equals(OpCodes.Newobj), "Unexpected opcode passed to EmitCall.");
// Push the return value if there is one.
if (methodInfo.GetReturnType() != typeof(void))
stackchange++;
// Pop the parameters.
if (methodInfo.GetParameterTypes() != null)
stackchange -= methodInfo.GetParameterTypes().Length;
// Pop the this parameter if the method is non-static and the
// instruction is not newobj.
if (!(methodInfo is SymbolMethod) && methodInfo.IsStatic == false && !(opcode.Equals(OpCodes.Newobj)))
stackchange--;
// Pop the optional parameters off the stack.
if (optionalParameterTypes != null)
stackchange -= optionalParameterTypes.Length;
UpdateStackSize(opcode, stackchange);
RecordTokenFixup();
m_length = PutInteger4(tk, m_length, m_ILStream);
}
public virtual void Emit(OpCode opcode, SignatureHelper signature)
{
int stackchange = 0;
ModuleBuilder modBuilder = (ModuleBuilder)m_methodBuilder.Module;
if (signature == null)
throw new ArgumentNullException("signature");
SignatureToken sig = modBuilder.GetSignatureToken(signature);
int tempVal = sig.Token;
EnsureCapacity(7);
InternalEmit(opcode);
// The only IL instruction that has VarPop behaviour, that takes a
// Signature token as a parameter is calli. Pop the parameters and
// the native function pointer. To be conservative, do not pop the
// this pointer since this information is not easily derived from
// SignatureHelper.
if (opcode.m_pop == StackBehaviour.Varpop) {
BCLDebug.Assert(opcode.Equals(OpCodes.Calli), "Unexpected opcode encountered for StackBehaviour VarPop.");
// Pop the arguments..
stackchange -= signature.ArgumentCount;
// Pop native function pointer off the stack.
stackchange--;
UpdateStackSize(opcode, stackchange);
}
RecordTokenFixup();
m_length = PutInteger4(tempVal, m_length, m_ILStream);
}
[System.Runtime.InteropServices.ComVisible(true)]
public virtual void Emit(OpCode opcode, ConstructorInfo con)
{
int stackchange = 0;
int tk = GetMethodToken(con, null);
EnsureCapacity(7);
InternalEmit(opcode);
// Make a conservative estimate by assuming a return type and no
// this parameter.
if (opcode.m_push == StackBehaviour.Varpush) {
// Instruction must be one of call or callvirt.
BCLDebug.Assert(opcode.Equals(OpCodes.Call) || opcode.Equals(OpCodes.Callvirt), "Unexpected opcode encountered for StackBehaviour of VarPush.");
stackchange++;
}
if (opcode.m_pop == StackBehaviour.Varpop) {
// Instruction must be one of call, callvirt or newobj.
BCLDebug.Assert(opcode.Equals(OpCodes.Call) || opcode.Equals(OpCodes.Callvirt) || opcode.Equals(OpCodes.Newobj), "Unex