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 \ DynamicILGenerator

SSCLI
  1. // ==++==
  2. //
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. //
  14. // ==--==
  16. namespace System.Reflection.Emit
  17. {
  18.    
  19.     using System;
  20.     using System.Globalization;
  21.     using TextWriter = System.IO.TextWriter;
  22.     using System.Diagnostics.SymbolStore;
  23.     using System.Runtime.InteropServices;
  24.     using System.Reflection;
  25.     using System.Collections;
  26.     using System.Security.Permissions;
  27.    
  28.     internal class DynamicILGenerator : ILGenerator
  29.     {
  30.        
  31.         internal DynamicScope m_scope;
  32.         private int m_methodSigToken;
  33.        
  34.         unsafe internal DynamicILGenerator(DynamicMethod method, byte[] methodSignature, int size) : base(method, size)
  35.         {
  36.             m_scope = new DynamicScope();
  37.             m_methodSigToken = m_scope.GetTokenFor(methodSignature);
  38.         }
  39.        
  40.        
  41.         unsafe internal RuntimeMethodHandle GetCallableMethod(void* module)
  42.         {
  43.             return new RuntimeMethodHandle(ModuleHandle.GetDynamicMethod(module, m_methodBuilder.Name, (byte[])m_scope[m_methodSigToken], new DynamicResolver(this)));
  44.         }
  45.        
  46.         // *** ILGenerator api ***
  47.        
  48.         public override LocalBuilder DeclareLocal(Type localType, bool pinned)
  49.         {
  50.             LocalBuilder localBuilder;
  51.             if (localType == null)
  52.                 throw new ArgumentNullException("localType");
  53.             if (localType.GetType() != typeof(RuntimeType))
  54.                 throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeType"));
  55.             localBuilder = new LocalBuilder(m_localCount, localType, m_methodBuilder);
  56.             // add the localType to local signature
  57.             m_localSignature.AddArgument(localType, pinned);
  58.             m_localCount++;
  59.             return localBuilder;
  60.         }
  61.        
  62.         //
  63.         //
  64.         // Token resolution calls
  65.         //
  66.         //
  67.         public override void Emit(OpCode opcode, MethodInfo meth)
  68.         {
  69.             if (meth == null)
  70.                 throw new ArgumentNullException("meth");
  71.            
  72.             int stackchange = 0;
  73.             int tempVal = 0;
  74.             DynamicMethod dynMeth = DynamicMethod.AsDynamicMethod(meth);
  75.             if (dynMeth == null) {
  76.                 if (!(meth is RuntimeMethodInfo))
  77.                     throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeMethodInfo"), "meth");
  78.                
  79.                 if (meth.DeclaringType != null && (meth.DeclaringType.IsGenericType || meth.DeclaringType.IsArray))
  80.                     tempVal = m_scope.GetTokenFor(meth.MethodHandle, meth.DeclaringType.TypeHandle);
  81.                 else
  82.                     tempVal = m_scope.GetTokenFor(meth.MethodHandle);
  83.             }
  84.             else {
  85.                 // rule out not allowed operations on DynamicMethods
  86.                 if (opcode.Equals(OpCodes.Ldtoken) || opcode.Equals(OpCodes.Ldftn) || opcode.Equals(OpCodes.Ldvirtftn)) {
  87.                     throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOpCodeOnDynamicMethod"));
  88.                 }
  89.                 tempVal = m_scope.GetTokenFor(dynMeth);
  90.             }
  91.            
  92.             EnsureCapacity(7);
  93.             InternalEmit(opcode);
  94.            
  95.             if (opcode.m_push == StackBehaviour.Varpush && meth.ReturnType != typeof(void)) {
  96.                 stackchange++;
  97.             }
  98.             if (opcode.m_pop == StackBehaviour.Varpop) {
  99.                 stackchange -= meth.GetParametersNoCopy().Length;
  100.             }
  101.             // Pop the "this" parameter if the method is non-static,
  102.             // and the instruction is not newobj/ldtoken/ldftn.
  103.             if (!meth.IsStatic && !(opcode.Equals(OpCodes.Newobj) || opcode.Equals(OpCodes.Ldtoken) || opcode.Equals(OpCodes.Ldftn))) {
  104.                 stackchange--;
  105.             }
  106.            
  107.             UpdateStackSize(opcode, stackchange);
  108.            
  109.             m_length = PutInteger4(tempVal, m_length, m_ILStream);
  110.         }
  111.        
  112.         [System.Runtime.InteropServices.ComVisible(true)]
  113.         public override void Emit(OpCode opcode, ConstructorInfo con)
  114.         {
  115.             if (con == null || !(con is RuntimeConstructorInfo))
  116.                 throw new ArgumentNullException("con");
  117.             if (con.DeclaringType != null && con.DeclaringType.IsGenericType)
  118.                 Emit(opcode, con.MethodHandle, con.DeclaringType.TypeHandle);
  119.             else
  120.                 Emit(opcode, con.MethodHandle);
  121.         }
  122.        
  123.         public void Emit(OpCode opcode, RuntimeMethodHandle meth)
  124.         {
  125.             if (meth.IsNullHandle())
  126.                 throw new ArgumentNullException("meth");
  127.            
  128.             // need to sort out the stack size story
  129.             //int stackchange = 0;
  130.             int tempVal = m_scope.GetTokenFor(meth);
  131.             EnsureCapacity(7);
  132.             InternalEmit(opcode);
  133.            
  134.             // need to sort out the stack size story
  135.             /*
  136.             if (opcode.m_push == StackBehaviour.Varpush
  137.                 && meth.ReturnType != typeof(void)) { stackchange++; }
  138.             if (opcode.m_pop  == StackBehaviour.Varpop) {
  139.               stackchange -= meth.GetParametersNoCopy().Length; }
  140.             if (!meth.IsStatic && !(opcode.Equals(OpCodes.Newobj))) {stackchange--; }
  141.            
  142.             UpdateStackSize(opcode, stackchange);
  143.             */           
  144.             // need to sort out the stack size story
  145. UpdateStackSize(opcode, 1);
  146.            
  147.             m_length = PutInteger4(tempVal, m_length, m_ILStream);
  148.         }
  149.        
  150.         public void Emit(OpCode opcode, RuntimeMethodHandle meth, RuntimeTypeHandle typeContext)
  151.         {
  152.             if (meth.IsNullHandle())
  153.                 throw new ArgumentNullException("meth");
  154.             if (typeContext.IsNullHandle())
  155.                 throw new ArgumentNullException("typeContext");
  156.            
  157.             // need to sort out the stack size story
  158.             //int stackchange = 0;
  159.             int tempVal = m_scope.GetTokenFor(meth, typeContext);
  160.             EnsureCapacity(7);
  161.             InternalEmit(opcode);
  162.            
  163.             // need to sort out the stack size story
  164.             /*
  165.             if (opcode.m_push == StackBehaviour.Varpush
  166.                 && meth.ReturnType != typeof(void)) { stackchange++; }
  167.             if (opcode.m_pop  == StackBehaviour.Varpop) {
  168.               stackchange -= meth.GetParametersNoCopy().Length; }
  169.             if (!meth.IsStatic && !(opcode.Equals(OpCodes.Newobj))) {stackchange--; }
  170.            
  171.             UpdateStackSize(opcode, stackchange);
  172.             */           
  173.             // need to sort out the stack size story
  174. UpdateStackSize(opcode, 1);
  175.            
  176.             m_length = PutInteger4(tempVal, m_length, m_ILStream);
  177.         }
  178.        
  179.         public override void Emit(OpCode opcode, Type type)
  180.         {
  181.             if (type == null)
  182.                 throw new ArgumentNullException("type");
  183.             Emit(opcode, type.TypeHandle);
  184.         }
  185.        
  186.         public void Emit(OpCode opcode, RuntimeTypeHandle typeHandle)
  187.         {
  188.             if (typeHandle.IsNullHandle())
  189.                 throw new ArgumentNullException("typeHandle");
  190.            
  191.             int tempVal = m_scope.GetTokenFor(typeHandle);
  192.             EnsureCapacity(7);
  193.             InternalEmit(opcode);
  194.             m_length = PutInteger4(tempVal, m_length, m_ILStream);
  195.         }
  196.        
  197.         public override void Emit(OpCode opcode, FieldInfo field)
  198.         {
  199.             if (field == null)
  200.                 throw new ArgumentNullException("field");
  201.             if (!(field is RuntimeFieldInfo))
  202.                 throw new ArgumentNullException("field");
  203.             Emit(opcode, field.FieldHandle);
  204.         }
  205.        
  206.         public void Emit(OpCode opcode, RuntimeFieldHandle fieldHandle)
  207.         {
  208.             if (fieldHandle.IsNullHandle())
  209.                 throw new ArgumentNullException("fieldHandle");
  210.            
  211.             int tempVal = m_scope.GetTokenFor(fieldHandle);
  212.             EnsureCapacity(7);
  213.             InternalEmit(opcode);
  214.             m_length = PutInteger4(tempVal, m_length, m_ILStream);
  215.         }
  216.        
  217.         public override void Emit(OpCode opcode, string str)
  218.         {
  219.             if (str == null)
  220.                 throw new ArgumentNullException("str");
  221.            
  222.             int tempVal = AddStringLiteral(str);
  223.             tempVal = tempVal | 1879048192;
  224.             EnsureCapacity(7);
  225.             InternalEmit(opcode);
  226.             m_length = PutInteger4(tempVal, m_length, m_ILStream);
  227.         }
  228.        
  229.         //
  230.         //
  231.         // Signature related calls (vararg, calli)
  232.         //
  233.         //
  234.         public override void EmitCalli(OpCode opcode, CallingConventions callingConvention, Type returnType, Type[] parameterTypes, Type[] optionalParameterTypes)
  235.         {
  236.             int stackchange = 0;
  237.             SignatureHelper sig;
  238.             if (optionalParameterTypes != null)
  239.                 if ((callingConvention & CallingConventions.VarArgs) == 0)
  240.                
  241.                     throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NotAVarArgCallingConvention"));
  243.            
  244.             sig = GetMemberRefSignature(callingConvention, returnType, parameterTypes, optionalParameterTypes);
  245.            
  246.             EnsureCapacity(7);
  247.             Emit(OpCodes.Calli);
  248.            
  249.             // The opcode passed in must be the calli instruction.
  250.             BCLDebug.Assert(opcode.Equals(OpCodes.Calli), "Unexpected opcode passed to EmitCalli.");
  251.             // If there is a non-void return type, push one.
  252.             if (returnType != typeof(void))
  253.                 stackchange++;
  254.             // Pop off arguments if any.
  255.             if (parameterTypes != null)
  256.                 stackchange -= parameterTypes.Length;
  257.             // Pop off vararg arguments.
  258.             if (optionalParameterTypes != null)
  259.                 stackchange -= optionalParameterTypes.Length;
  260.             // Pop the this parameter if the method has a this parameter.
  261.             if ((callingConvention & CallingConventions.HasThis) == CallingConventions.HasThis)
  262.                 stackchange--;
  263.             // Pop the native function pointer.
  264.             stackchange--;
  265.             UpdateStackSize(opcode, stackchange);
  266.            
  267.             int token = AddSignature(sig.GetSignature(true));
  268.             m_length = PutInteger4(token, m_length, m_ILStream);
  269.         }
  270.        
  271.         public override void EmitCalli(OpCode opcode, CallingConvention unmanagedCallConv, Type returnType, Type[] parameterTypes)
  272.         {
  273.             int stackchange = 0;
  274.             int cParams = 0;
  275.             int i;
  276.             SignatureHelper sig;
  277.            
  278.             // The opcode passed in must be the calli instruction.
  279.             BCLDebug.Assert(opcode.Equals(OpCodes.Calli), "Unexpected opcode passed to EmitCalli.");
  280.             if (parameterTypes != null)
  281.                 cParams = parameterTypes.Length;
  282.            
  283.             sig = SignatureHelper.GetMethodSigHelper(unmanagedCallConv, returnType);
  284.            
  285.             if (parameterTypes != null)
  286.                 for (i = 0; i < cParams; i++)
  287.                     sig.AddArgument(parameterTypes[i]);
  289.            
  290.             // If there is a non-void return type, push one.
  291.             if (returnType != typeof(void))
  292.                 stackchange++;
  293.            
  294.             // Pop off arguments if any.
  295.             if (parameterTypes != null)
  296.                 stackchange -= cParams;
  297.            
  298.             // Pop the native function pointer.
  299.             stackchange--;
  300.             UpdateStackSize(opcode, stackchange);
  301.            
  302.             EnsureCapacity(7);
  303.             Emit(OpCodes.Calli);
  304.             int token = AddSignature(sig.GetSignature(true));
  305.             m_length = PutInteger4(token, m_length, m_ILStream);
  306.         }
  307.        
  308.         public override void EmitCall(OpCode opcode, MethodInfo methodInfo, Type[] optionalParameterTypes)
  309.         {
  310.             int tk;
  311.             int stackchange = 0;
  312.            
  313.             if (methodInfo == null)
  314.                 throw new ArgumentNullException("methodInfo");
  315.            
  316.             if (methodInfo.ContainsGenericParameters)
  317.                 throw new ArgumentException(Environment.GetResourceString("Argument_GenericsInvalid"), "methodInfo");
  318.            
  319.             if (methodInfo.DeclaringType != null && methodInfo.DeclaringType.ContainsGenericParameters)
  320.                 throw new ArgumentException(Environment.GetResourceString("Argument_GenericsInvalid"), "methodInfo");
  321.            
  322.             tk = GetMemberRefToken(methodInfo, optionalParameterTypes);
  323.            
  324.             EnsureCapacity(7);
  325.             InternalEmit(opcode);
  326.            
  327.             // The opcode must be one of call, callvirt, or newobj.
  328.             BCLDebug.Assert(opcode.Equals(OpCodes.Call) || opcode.Equals(OpCodes.Callvirt) || opcode.Equals(OpCodes.Newobj), "Unexpected opcode passed to EmitCall.");
  329.            
  330.             // Push the return value if there is one.
  331.             if (methodInfo.ReturnType != typeof(void))
  332.                 stackchange++;
  333.             // Pop the parameters.
  334.             stackchange -= methodInfo.GetParameterTypes().Length;
  335.             // Pop the this parameter if the method is non-static and the
  336.             // instruction is not newobj.
  337.             if (!(methodInfo is SymbolMethod) && methodInfo.IsStatic == false && !(opcode.Equals(OpCodes.Newobj)))
  338.                 stackchange--;
  339.             // Pop the optional parameters off the stack.
  340.             if (optionalParameterTypes != null)
  341.                 stackchange -= optionalParameterTypes.Length;
  342.             UpdateStackSize(opcode, stackchange);
  343.            
  344.             m_length = PutInteger4(tk, m_length, m_ILStream);
  345.         }
  346.        
  347.         public override void Emit(OpCode opcode, SignatureHelper signature)
  348.         {
  349.             int stackchange = 0;
  350.             if (signature == null)
  351.                 throw new ArgumentNullException("signature");
  352.            
  353.             EnsureCapacity(7);
  354.             InternalEmit(opcode);
  355.            
  356.             // The only IL instruction that has VarPop behaviour, that takes a
  357.             // Signature token as a parameter is calli. Pop the parameters and
  358.             // the native function pointer. To be conservative, do not pop the
  359.             // this pointer since this information is not easily derived from
  360.             // SignatureHelper.
  361.             if (opcode.m_pop == StackBehaviour.Varpop) {
  362.                 BCLDebug.Assert(opcode.Equals(OpCodes.Calli), "Unexpected opcode encountered for StackBehaviour VarPop.");
  363.                 // Pop the arguments..
  364.                 stackchange -= signature.ArgumentCount;
  365.                 // Pop native function pointer off the stack.
  366.                 stackchange--;
  367.                 UpdateStackSize(opcode, stackchange);
  368.             }
  369.            
  370.             int token = AddSignature(signature.GetSignature(true));
  371.             ;
  372.             m_length = PutInteger4(token, m_length, m_ILStream);
  373.         }
  374.        
  375.         //
  376.         //
  377.         // Exception related generation
  378.         //
  379.         //
  380.         public override Label BeginExceptionBlock()
  381.         {
  382.             return base.BeginExceptionBlock();
  383.         }
  384.        
  385.         public override void EndExceptionBlock()
  386.         {
  387.             base.EndExceptionBlock();
  388.         }
  389.        
  390.         public override void BeginExceptFilterBlock()
  391.         {
  392.             throw new NotSupportedException(Environment.GetResourceString("InvalidOperation_NotAllowedInDynamicMethod"));
  393.         }
  394.        
  395.         public override void BeginCatchBlock(Type exceptionType)
  396.         {
  397.             if (m_currExcStackCount == 0)
  398.                 throw new NotSupportedException(Environment.GetResourceString("Argument_NotInExceptionBlock"));
  399.            
  400.             __ExceptionInfo current = m_currExcStack[m_currExcStackCount - 1];
  401.            
  402.             if (current.GetCurrentState() == __ExceptionInfo.State_Filter) {
  403.                 if (exceptionType != null) {
  404.                     throw new ArgumentException(Environment.GetResourceString("Argument_ShouldNotSpecifyExceptionType"));
  405.                 }
  406.                
  407.                 this.Emit(OpCodes.Endfilter);
  408.             }
  409.             else {
  410.                 // execute this branch if previous clause is Catch or Fault
  411.                 if (exceptionType == null) {
  412.                     throw new ArgumentNullException("exceptionType");
  413.                 }
  414.                
  415.                 if (exceptionType.GetType() != typeof(RuntimeType))
  416.                     throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeType"));
  417.                
  418.                 Label endLabel = current.GetEndLabel();
  419.                 this.Emit(OpCodes.Leave, endLabel);
  420.                
  421.                 // if this is a catch block the exception will be pushed on the stack and we need to update the stack info
  422.                 UpdateStackSize(OpCodes.Nop, 1);
  423.             }
  424.            
  425.             current.MarkCatchAddr(m_length, exceptionType);
  426.            
  427.            
  428.             // this is relying on too much implementation details of the base and so it's highly breaking
  429.             // Need to have a more integreted story for exceptions
  430.             current.m_filterAddr[current.m_currentCatch - 1] = m_scope.GetTokenFor(exceptionType.TypeHandle);
  431.         }
  432.        
  433.         public override void BeginFaultBlock()
  434.         {
  435.             throw new NotSupportedException(Environment.GetResourceString("InvalidOperation_NotAllowedInDynamicMethod"));
  436.         }
  437.        
  438.         public override void BeginFinallyBlock()
  439.         {
  440.             base.BeginFinallyBlock();
  441.         }
  442.        
  443.         //
  444.         //
  445.         // debugger related calls.
  446.         //
  447.         //
  448.         public override void UsingNamespace(string ns)
  449.         {
  450.             throw new NotSupportedException(Environment.GetResourceString("InvalidOperation_NotAllowedInDynamicMethod"));
  451.         }
  452.        
  453.         public override void MarkSequencePoint(ISymbolDocumentWriter document, int startLine, int startColumn, int endLine, int endColumn)
  454.         {
  455.             throw new NotSupportedException(Environment.GetResourceString("InvalidOperation_NotAllowedInDynamicMethod"));
  456.         }
  457.        
  458.         public override void BeginScope()
  459.         {
  460.             throw new NotSupportedException(Environment.GetResourceString("InvalidOperation_NotAllowedInDynamicMethod"));
  461.         }
  462.        
  463.         public override void EndScope()
  464.         {
  465.             throw new NotSupportedException(Environment.GetResourceString("InvalidOperation_NotAllowedInDynamicMethod"));
  466.         }
  467.        
  468.         //
  469.         // private implementation
  470.         //
  471.         internal override int GetMaxStackSize()
  472.         {
  473.             return m_maxStackSize;
  474.         }
  475.        
  476.         internal override int GetMemberRefToken(MethodBase methodInfo, Type[] optionalParameterTypes)
  477.         {
  478.             Type[] parameterTypes;
  479.            
  480.             if (optionalParameterTypes != null)
  481.                 if ((methodInfo.CallingConvention & CallingConventions.VarArgs) == 0)
  482.                
  483.                     throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NotAVarArgCallingConvention"));
  485.            
  486.             if (!(methodInfo is RuntimeMethodInfo) && DynamicMethod.AsDynamicMethod(methodInfo) == null)
  487.                 throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeMethodInfo"), "methodInfo");
  488.            
  489.             ParameterInfo[] paramInfo = methodInfo.GetParametersNoCopy();
  490.             if (paramInfo != null && paramInfo.Length != 0) {
  491.                 parameterTypes = new Type[paramInfo.Length];
  492.                 for (int i = 0; i < paramInfo.Length; i++) {
  493.                     parameterTypes[i] = paramInfo[i].ParameterType;
  494.                 }
  495.             }
  496.             else
  497.                 parameterTypes = null;
  498.            
  499.             SignatureHelper sig = GetMemberRefSignature(methodInfo.CallingConvention, methodInfo.GetReturnType(), parameterTypes, optionalParameterTypes);
  500.             return m_scope.GetTokenFor(new VarArgMethod(methodInfo as MethodInfo, sig));
  501.         }
  502.        
  503.         internal override SignatureHelper GetMemberRefSignature(CallingConventions call, Type returnType, Type[] parameterTypes, Type[] optionalParameterTypes)
  504.         {
  505.             int cParams;
  506.             int i;
  507.             SignatureHelper sig;
  508.             if (parameterTypes == null)
  509.                 cParams = 0;
  510.             else
  511.                 cParams = parameterTypes.Length;
  512.             sig = SignatureHelper.GetMethodSigHelper(call, returnType);
  513.             for (i = 0; i < cParams; i++)
  514.                 sig.AddArgument(parameterTypes[i]);
  515.             if (optionalParameterTypes != null && optionalParameterTypes.Length != 0) {
  516.                 // add the sentinel
  517.                 sig.AddSentinel();
  518.                 for (i = 0; i < optionalParameterTypes.Length; i++)
  519.                     sig.AddArgument(optionalParameterTypes[i]);
  520.             }
  521.             return sig;
  522.         }
  523.        
  524.         private int AddStringLiteral(string s)
  525.         {
  526.             int token = m_scope.GetTokenFor(s);
  527.             return token | 1879048192;
  528.         }
  529.        
  530.         private int AddSignature(byte[] sig)
  531.         {
  532.             int token = m_scope.GetTokenFor(sig);
  533.             return token | 285212672;
  534.         }
  535.        
  536.     }
  537.    
  538.     internal class DynamicResolver : Resolver
  539.     {
  540.         #region Private Data Members
  541.         private __ExceptionInfo[] m_exceptions;
  542.         private byte[] m_exceptionHeader;
  543.         private DynamicMethod m_method;
  544.         private byte[] m_code;
  545.         private byte[] m_localSignature;
  546.         private int m_stackSize;
  547.         private DynamicScope m_scope;
  548.         #endregion
  549.        
  550.         #region Internal Methods
  551.         internal DynamicResolver(DynamicILGenerator ilGenerator)
  552.         {
  553.             m_stackSize = ilGenerator.GetMaxStackSize();
  554.             m_exceptions = ilGenerator.GetExceptions();
  555.             m_code = ilGenerator.BakeByteArray();
  556.             m_localSignature = ilGenerator.m_localSignature.InternalGetSignatureArray();
  557.             m_scope = ilGenerator.m_scope;
  558.            
  559.             m_method = (DynamicMethod)ilGenerator.m_methodBuilder;
  560.             m_method.m_resolver = this;
  561.         }
  562.        
  563.         internal DynamicResolver(DynamicILInfo dynamicILInfo)
  564.         {
  565.             m_stackSize = dynamicILInfo.MaxStackSize;
  566.             m_code = dynamicILInfo.Code;
  567.             m_localSignature = dynamicILInfo.LocalSignature;
  568.             m_exceptionHeader = dynamicILInfo.Exceptions;
  569.             //m_exceptions = dynamicILInfo.Exceptions;
  570.             m_scope = dynamicILInfo.DynamicScope;
  571.            
  572.             m_method = dynamicILInfo.DynamicMethod;
  573.             m_method.m_resolver = this;
  574.         }
  575.        
  576.         //
  577.         //
  578.         ~DynamicResolver()
  579.         {
  580.             DynamicMethod method = m_method;
  581.            
  582.             if (method == null)
  583.                 return;
  584.            
  585.             if (method.m_method.IsNullHandle())
  586.                 return;
  587.            
  588.             DestroyScout scout = null;
  589.             try {
  590.                 scout = new DestroyScout();
  591.             }
  592.             catch {
  593.                 // We go over all DynamicMethodDesc during AppDomain shutdown and make sure
  594.                 // that everything associated with them is released. So it is ok to skip reregistration
  595.                 // for finalization during appdomain shutdown
  596.                 if (!Environment.HasShutdownStarted && !AppDomain.CurrentDomain.IsFinalizingForUnload()) {
  597.                     // Try again later.
  598.                     GC.ReRegisterForFinalize(this);
  599.                 }
  600.                 return;
  601.             }
  602.            
  603.             // We can never ever have two active destroy scouts for the same method. We need to initialize the scout
  604.             // outside the try/reregister block to avoid possibility of reregistration for finalization with active scout.
  605.             scout.m_method = method.m_method;
  606.         }
  607.        
  608.         private class DestroyScout
  609.         {
  610.             internal RuntimeMethodHandle m_method;
  611.            
  612.             ~DestroyScout()
  613.             {
  614.                 if (m_method.IsNullHandle())
  615.                     return;
  616.                
  617.                 // It is not safe to destroy the method if the managed resolver is alive.
  618.                 if (m_method.GetResolver() != null) {
  619.                     if (!Environment.HasShutdownStarted && !AppDomain.CurrentDomain.IsFinalizingForUnload()) {
  620.                         // Somebody might have been holding a reference on us via weak handle.
  621.                         // We will keep trying. It will be hopefully released eventually.
  622.                         GC.ReRegisterForFinalize(this);
  623.                     }
  624.                     return;
  625.                 }
  626.                
  627.                 m_method.Destroy();
  628.             }
  629.         }
  630.        
  631.         // Keep in sync with vm/dynamicmethod.h
  632.         internal enum SecurityControlFlags
  633.         {
  634.             SkipVisibilityChecks = 1
  635.         }
  636.        
  637.         internal override void GetJitContext(ref int securityControlFlags, ref RuntimeTypeHandle typeOwner)
  638.         {
  639.             securityControlFlags = (m_method.m_skipVisibility) ? (int)SecurityControlFlags.SkipVisibilityChecks : 0;
  640.             typeOwner = (m_method.m_typeOwner != null) ? m_method.m_typeOwner.TypeHandle : RuntimeTypeHandle.EmptyHandle;
  641.         }
  642.        
  643.         internal override byte[] GetCodeInfo(ref int stackSize, ref int initLocals, ref int EHCount)
  644.         {
  645.             stackSize = m_stackSize;
  646.             if (m_exceptionHeader != null && m_exceptionHeader.Length != 0) {
  647.                 if (m_exceptionHeader.Length < 4)
  648.                     throw new FormatException();
  649.                
  650.                 byte header = m_exceptionHeader[0];
  651.                
  652.                 // Fat
  653.                 if ((header & 64) != 0) {
  654.                     byte[] size = new byte[4];
  655.                     for (int q = 0; q < 3; q++)
  656.                         size[q] = m_exceptionHeader[q + 1];
  657.                     EHCount = (BitConverter.ToInt32(size, 0) - 4) / 24;
  658.                 }
  659.                 else
  660.                     EHCount = (m_exceptionHeader[1] - 2) / 12;
  661.             }
  662.             else {
  663.                 EHCount = ILGenerator.CalculateNumberOfExceptions(m_exceptions);
  664.             }
  665.             initLocals = (m_method.InitLocals) ? 1 : 0;
  666.             return m_code;
  667.         }
  668.        
  669.         internal override byte[] GetLocalsSignature()
  670.         {
  671.             return m_localSignature;
  672.         }
  673.        
  674.         unsafe internal override byte[] GetRawEHInfo()
  675.         {
  676.             return m_exceptionHeader;
  677.         }
  678.        
  679.         unsafe internal override void GetEHInfo(int excNumber, void* exc)
  680.         {
  681.             CORINFO_EH_CLAUSE* exception = (CORINFO_EH_CLAUSE*)exc;
  682.             for (int i = 0; i < m_exceptions.Length; i++) {
  683.                 int excCount = m_exceptions[i].GetNumberOfCatches();
  684.                 if (excNumber < excCount) {
  685.                     // found the right exception block
  686.                     exception->Flags = m_exceptions[i].GetExceptionTypes()[excNumber];
  687.                     exception->Flags |= Resolver.COR_ILEXCEPTION_CLAUSE_MUST_CACHE_CLASS;
  688.                     exception->TryOffset = m_exceptions[i].GetStartAddress();
  689.                     if ((exception->Flags & __ExceptionInfo.Finally) != __ExceptionInfo.Finally)
  690.                         exception->TryLength = m_exceptions[i].GetEndAddress() - exception->TryOffset;
  691.                     else
  692.                         exception->TryLength = m_exceptions[i].GetFinallyEndAddress() - exception->TryOffset;
  693.                     exception->HandlerOffset = m_exceptions[i].GetCatchAddresses()[excNumber];
  694.                     exception->HandlerLength = m_exceptions[i].GetCatchEndAddresses()[excNumber] - exception->HandlerOffset;
  695.                     // this is cheating because the filter address is the token of the class only for light code gen
  696.                     exception->ClassTokenOrFilterOffset = m_exceptions[i].GetFilterAddresses()[excNumber];
  697.                     break;
  698.                 }
  699.                 excNumber -= excCount;
  700.             }
  701.         }
  702.        
  703.         internal override string GetStringLiteral(int token)
  704.         {
  705.             return m_scope.GetString(token);
  706.         }
  707.        
  708.         internal override int IsValidToken(int token)
  709.         {
  710.             return (m_scope[token] != null) ? 1 : 0;
  711.         }
  712.        
  713.         unsafe internal override void* GetInstantiationInfo(int token)
  714.         {
  715.             GenericMethodInfo gmi = m_scope[token] as GenericMethodInfo;
  716.             if (gmi != null) {
  717.                 return (void*)gmi.m_context.Value;
  718.             }
  719.             return null;
  720.         }
  721.        
  722.         unsafe internal override void* ResolveToken(int token)
  723.         {
  724.             object handle = m_scope[token];
  725.            
  726.             if (handle is RuntimeTypeHandle) {
  727.                 RuntimeTypeHandle typeHandle = (RuntimeTypeHandle)handle;
  728.                 return (void*)typeHandle.Value;
  729.             }
  730.             else if (handle is RuntimeMethodHandle) {
  731.                 RuntimeMethodHandle methodHandle = (RuntimeMethodHandle)handle;
  732.                 return (void*)methodHandle.Value;
  733.             }
  734.             else if (handle is RuntimeFieldHandle) {
  735.                 RuntimeFieldHandle fieldHandle = (RuntimeFieldHandle)handle;
  736.                 return (void*)fieldHandle.Value;
  737.             }
  738.             else if (handle is DynamicMethod) {
  739.                 DynamicMethod dynMeth = (DynamicMethod)handle;
  740.                 RuntimeMethodHandle methodHandle = dynMeth.GetMethodDescriptor();
  741.                 return (void*)methodHandle.Value;
  742.             }
  743.             else if (handle is GenericMethodInfo) {
  744.               &