/// <summary>Sets the name and lexical scope of this local variable.</summary> /// <param name="name">The name of the local variable. </param> /// <param name="startOffset">The beginning offset of the lexical scope of the local variable. </param> /// <param name="endOffset">The ending offset of the lexical scope of the local variable. </param> /// <exception cref="T:System.InvalidOperationException">The containing type has been created with <see cref="M:System.Reflection.Emit.TypeBuilder.CreateType" />.-or- There is no symbolic writer defined for the containing module. </exception> /// <exception cref="T:System.NotSupportedException">This local is defined in a dynamic method, rather than in a method of a dynamic type.</exception> // Token: 0x060049F6 RID: 18934 RVA: 0x0010B4A8 File Offset: 0x001096A8 public void SetLocalSymInfo(string name, int startOffset, int endOffset) { MethodBuilder methodBuilder = this.m_methodBuilder as MethodBuilder; if (methodBuilder == null) { throw new NotSupportedException(); } ModuleBuilder moduleBuilder = (ModuleBuilder)methodBuilder.Module; if (methodBuilder.IsTypeCreated()) { throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_TypeHasBeenCreated")); } if (moduleBuilder.GetSymWriter() == null) { throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NotADebugModule")); } SignatureHelper fieldSigHelper = SignatureHelper.GetFieldSigHelper(moduleBuilder); fieldSigHelper.AddArgument(this.m_localType); int num; byte[] sourceArray = fieldSigHelper.InternalGetSignature(out num); byte[] array = new byte[num - 1]; Array.Copy(sourceArray, 1, array, 0, num - 1); int currentActiveScopeIndex = methodBuilder.GetILGenerator().m_ScopeTree.GetCurrentActiveScopeIndex(); if (currentActiveScopeIndex == -1) { methodBuilder.m_localSymInfo.AddLocalSymInfo(name, array, this.m_localIndex, startOffset, endOffset); return; } methodBuilder.GetILGenerator().m_ScopeTree.AddLocalSymInfoToCurrentScope(name, array, this.m_localIndex, startOffset, endOffset); }
/******************* * * This is different from CustomAttribute. This is stored into the SymWriter. * ********************/ /// <include file='doc\MethodBuilder.uex' path='docs/doc[@for="MethodBuilder.SetSymCustomAttribute"]/*' /> public void SetSymCustomAttribute( String name, // SymCustomAttribute's name byte[] data) // the data blob { m_containingType.ThrowIfCreated(); ModuleBuilder dynMod = (ModuleBuilder)m_module; if (dynMod.GetSymWriter() == null) { // Cannot SetSymCustomAttribute when it is not a debug module throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NotADebugModule")); } SymbolToken tk = new SymbolToken(m_mdMethod.Token); dynMod.GetSymWriter().SetSymAttribute(tk, name, data); }
/// <summary>设置该局部变量的名称和词法范围。</summary> /// <param name="name">局部变量的名称。</param> /// <param name="startOffset">局部变量词法范围的开始偏移量。</param> /// <param name="endOffset">局部变量词法范围的结束偏移量。</param> /// <exception cref="T:System.InvalidOperationException">已经用 <see cref="M:System.Reflection.Emit.TypeBuilder.CreateType" /> 创建了该包含类型。- 或 -没有为包含模块定义的符号编写器。</exception> /// <exception cref="T:System.NotSupportedException">此局部变量是使用动态方法(而不是动态类型的方法)来定义的。</exception> public void SetLocalSymInfo(string name, int startOffset, int endOffset) { MethodBuilder methodBuilder = this.m_methodBuilder as MethodBuilder; if ((MethodInfo)methodBuilder == (MethodInfo)null) { throw new NotSupportedException(); } ModuleBuilder moduleBuilder = (ModuleBuilder)methodBuilder.Module; if (methodBuilder.IsTypeCreated()) { throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_TypeHasBeenCreated")); } if (moduleBuilder.GetSymWriter() == null) { throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NotADebugModule")); } SignatureHelper fieldSigHelper = SignatureHelper.GetFieldSigHelper((Module)moduleBuilder); Type clsArgument = this.m_localType; fieldSigHelper.AddArgument(clsArgument); int num; // ISSUE: explicit reference operation // ISSUE: variable of a reference type int& length1 = @num; byte[] signature1 = fieldSigHelper.InternalGetSignature(length1); byte[] signature2 = new byte[num - 1]; int sourceIndex = 1; byte[] numArray = signature2; int destinationIndex = 0; int length2 = num - 1; Array.Copy((Array)signature1, sourceIndex, (Array)numArray, destinationIndex, length2); if (methodBuilder.GetILGenerator().m_ScopeTree.GetCurrentActiveScopeIndex() == -1) { methodBuilder.m_localSymInfo.AddLocalSymInfo(name, signature2, this.m_localIndex, startOffset, endOffset); } else { methodBuilder.GetILGenerator().m_ScopeTree.AddLocalSymInfoToCurrentScope(name, signature2, this.m_localIndex, startOffset, endOffset); } }
public void SetSymCustomAttribute(String name, byte[] data) { ThrowIfGeneric(); // This is different from CustomAttribute. This is stored into the SymWriter. m_containingType.ThrowIfCreated(); ModuleBuilder dynMod = (ModuleBuilder)m_module; if (dynMod.GetSymWriter() == null) { // Cannot SetSymCustomAttribute when it is not a debug module throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NotADebugModule")); } if (m_symCustomAttrs == null) { m_symCustomAttrs = new ArrayList(); } m_symCustomAttrs.Add(new SymCustomAttr(name, data)); }
/********************************************** * Sets the IL of the method. An ILGenerator is passed as an argument and the method * queries this instance to get all of the information which it needs. * @param il An ILGenerator with some il defined. * @exception ArgumentException if <EM>il</EM> is null. **********************************************/ internal void CreateMethodBodyHelper(ILGenerator il) { __ExceptionInfo[] excp; int counter = 0; int[] filterAddrs; int[] catchAddrs; int[] catchEndAddrs; Type[] catchClass; int[] type; int numCatch; int start, end; ModuleBuilder dynMod = (ModuleBuilder)m_module; m_containingType.ThrowIfCreated(); if (m_bIsBaked) { throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_MethodHasBody")); } if (il == null) { throw new ArgumentNullException("il"); } if (il.m_methodBuilder != this && il.m_methodBuilder != null) { // you don't need to call CreateMethodBody when you get your ILGenerator // through MethodBuilder::GetILGenerator. // throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_BadILGeneratorUsage")); } if ((m_dwMethodImplFlags & MethodImplAttributes.PreserveSig) != 0 || (m_dwMethodImplFlags & MethodImplAttributes.CodeTypeMask) != MethodImplAttributes.IL || (m_dwMethodImplFlags & MethodImplAttributes.Unmanaged) != 0 || (m_iAttributes & MethodAttributes.PinvokeImpl) != 0) { // cannot attach method body if methodimpl is marked not marked as managed IL // @todo: what error should we throw here? // throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_ShouldNotHaveMethodBody")); } if (il.m_ScopeTree.m_iOpenScopeCount != 0) { // There are still unclosed local scope throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_OpenLocalVariableScope")); } m_ubBody = il.BakeByteArray(); m_RVAFixups = il.GetRVAFixups(); mm_mdMethodFixups = il.GetTokenFixups(); //Okay, now the fun part. Calculate all of the exceptions. excp = il.GetExceptions(); m_numExceptions = CalculateNumberOfExceptions(excp); if (m_numExceptions > 0) { m_exceptions = new __ExceptionInstance[m_numExceptions]; for (int i = 0; i < excp.Length; i++) { filterAddrs = excp[i].GetFilterAddresses(); catchAddrs = excp[i].GetCatchAddresses(); catchEndAddrs = excp[i].GetCatchEndAddresses(); catchClass = excp[i].GetCatchClass(); // track the reference of the catch class for (int j = 0; j < catchClass.Length; j++) { if (catchClass[j] != null) { dynMod.GetTypeToken(catchClass[j]); } } numCatch = excp[i].GetNumberOfCatches(); start = excp[i].GetStartAddress(); end = excp[i].GetEndAddress(); type = excp[i].GetExceptionTypes(); for (int j = 0; j < numCatch; j++) { int tkExceptionClass = 0; if (catchClass[j] != null) { tkExceptionClass = dynMod.GetTypeToken(catchClass[j]).Token; } switch (type[j]) { case __ExceptionInfo.None: case __ExceptionInfo.Fault: case __ExceptionInfo.Filter: m_exceptions[counter++] = new __ExceptionInstance(start, end, filterAddrs[j], catchAddrs[j], catchEndAddrs[j], type[j], tkExceptionClass); break; case __ExceptionInfo.Finally: m_exceptions[counter++] = new __ExceptionInstance(start, excp[i].GetFinallyEndAddress(), filterAddrs[j], catchAddrs[j], catchEndAddrs[j], type[j], tkExceptionClass); break; } } } } m_bIsBaked = true; if (dynMod.GetSymWriter() != null) { // set the debugging information such as scope and line number // if it is in a debug module // SymbolToken tk = new SymbolToken(m_mdMethod.Token); ISymbolWriter symWriter = dynMod.GetSymWriter(); // call OpenMethod to make this method the current method symWriter.OpenMethod(tk); // call OpenScope because OpenMethod no longer implicitly creating // the top-levelsmethod scope // symWriter.OpenScope(0); if (m_localSymInfo != null) { m_localSymInfo.EmitLocalSymInfo(symWriter); } il.m_ScopeTree.EmitScopeTree(symWriter); il.m_LineNumberInfo.EmitLineNumberInfo(symWriter); symWriter.CloseScope(il.m_length); symWriter.CloseMethod(); } }
internal void CreateMethodBodyHelper(ILGenerator il) { // Sets the IL of the method. An ILGenerator is passed as an argument and the method // queries this instance to get all of the information which it needs. if (il == null) { throw new ArgumentNullException(nameof(il)); } __ExceptionInfo[] excp; int counter = 0; int[] filterAddrs; int[] catchAddrs; int[] catchEndAddrs; Type[] catchClass; int[] type; int numCatch; int start, end; ModuleBuilder dynMod = (ModuleBuilder)m_module; m_containingType.ThrowIfCreated(); if (m_bIsBaked) { throw new InvalidOperationException(SR.InvalidOperation_MethodHasBody); } if (il.m_methodBuilder != this && il.m_methodBuilder != null) { // you don't need to call DefineBody when you get your ILGenerator // through MethodBuilder::GetILGenerator. // throw new InvalidOperationException(SR.InvalidOperation_BadILGeneratorUsage); } ThrowIfShouldNotHaveBody(); if (il.m_ScopeTree.m_iOpenScopeCount != 0) { // There are still unclosed local scope throw new InvalidOperationException(SR.InvalidOperation_OpenLocalVariableScope); } m_ubBody = il.BakeByteArray(); m_mdMethodFixups = il.GetTokenFixups(); //Okay, now the fun part. Calculate all of the exceptions. excp = il.GetExceptions() !; int numExceptions = CalculateNumberOfExceptions(excp); if (numExceptions > 0) { m_exceptions = new ExceptionHandler[numExceptions]; for (int i = 0; i < excp.Length; i++) { filterAddrs = excp[i].GetFilterAddresses(); catchAddrs = excp[i].GetCatchAddresses(); catchEndAddrs = excp[i].GetCatchEndAddresses(); catchClass = excp[i].GetCatchClass(); numCatch = excp[i].GetNumberOfCatches(); start = excp[i].GetStartAddress(); end = excp[i].GetEndAddress(); type = excp[i].GetExceptionTypes(); for (int j = 0; j < numCatch; j++) { int tkExceptionClass = 0; if (catchClass[j] != null) { tkExceptionClass = dynMod.GetTypeTokenInternal(catchClass[j]).Token; } switch (type[j]) { case __ExceptionInfo.None: case __ExceptionInfo.Fault: case __ExceptionInfo.Filter: m_exceptions[counter++] = new ExceptionHandler(start, end, filterAddrs[j], catchAddrs[j], catchEndAddrs[j], type[j], tkExceptionClass); break; case __ExceptionInfo.Finally: m_exceptions[counter++] = new ExceptionHandler(start, excp[i].GetFinallyEndAddress(), filterAddrs[j], catchAddrs[j], catchEndAddrs[j], type[j], tkExceptionClass); break; } } } } m_bIsBaked = true; if (dynMod.GetSymWriter() != null) { // set the debugging information such as scope and line number // if it is in a debug module // SymbolToken tk = new SymbolToken(MetadataTokenInternal); ISymbolWriter symWriter = dynMod.GetSymWriter() !; // TODO-NULLABLE: https://github.com/dotnet/csharplang/issues/2388 // call OpenMethod to make this method the current method symWriter.OpenMethod(tk); // call OpenScope because OpenMethod no longer implicitly creating // the top-levelsmethod scope // symWriter.OpenScope(0); if (m_symCustomAttrs != null) { foreach (SymCustomAttr symCustomAttr in m_symCustomAttrs) { dynMod.GetSymWriter() !.SetSymAttribute( new SymbolToken(MetadataTokenInternal), symCustomAttr.m_name, symCustomAttr.m_data); } } if (m_localSymInfo != null) { m_localSymInfo.EmitLocalSymInfo(symWriter); } il.m_ScopeTree.EmitScopeTree(symWriter); il.m_LineNumberInfo.EmitLineNumberInfo(symWriter); symWriter.CloseScope(il.ILOffset); symWriter.CloseMethod(); } }
internal void CreateMethodBodyHelper(ILGenerator il) { if (il == null) { throw new ArgumentNullException("il"); } int num = 0; ModuleBuilder module = this.m_module; this.m_containingType.ThrowIfCreated(); if (this.m_bIsBaked) { throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_MethodHasBody")); } if ((il.m_methodBuilder != this) && (il.m_methodBuilder != null)) { throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_BadILGeneratorUsage")); } this.ThrowIfShouldNotHaveBody(); if (il.m_ScopeTree.m_iOpenScopeCount != 0) { throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_OpenLocalVariableScope")); } this.m_ubBody = il.BakeByteArray(); this.m_RVAFixups = il.GetRVAFixups(); this.m_mdMethodFixups = il.GetTokenFixups(); __ExceptionInfo[] exceptions = il.GetExceptions(); this.m_numExceptions = this.CalculateNumberOfExceptions(exceptions); if (this.m_numExceptions > 0) { this.m_exceptions = new __ExceptionInstance[this.m_numExceptions]; for (int i = 0; i < exceptions.Length; i++) { int[] filterAddresses = exceptions[i].GetFilterAddresses(); int[] catchAddresses = exceptions[i].GetCatchAddresses(); int[] catchEndAddresses = exceptions[i].GetCatchEndAddresses(); Type[] catchClass = exceptions[i].GetCatchClass(); for (int j = 0; j < catchClass.Length; j++) { if (catchClass[j] != null) { module.GetTypeTokenInternal(catchClass[j]); } } int numberOfCatches = exceptions[i].GetNumberOfCatches(); int startAddress = exceptions[i].GetStartAddress(); int endAddress = exceptions[i].GetEndAddress(); int[] exceptionTypes = exceptions[i].GetExceptionTypes(); for (int k = 0; k < numberOfCatches; k++) { int exceptionClass = 0; if (catchClass[k] != null) { exceptionClass = module.GetTypeTokenInternal(catchClass[k]).Token; } switch (exceptionTypes[k]) { case 0: case 1: case 4: this.m_exceptions[num++] = new __ExceptionInstance(startAddress, endAddress, filterAddresses[k], catchAddresses[k], catchEndAddresses[k], exceptionTypes[k], exceptionClass); break; case 2: this.m_exceptions[num++] = new __ExceptionInstance(startAddress, exceptions[i].GetFinallyEndAddress(), filterAddresses[k], catchAddresses[k], catchEndAddresses[k], exceptionTypes[k], exceptionClass); break; } } } } this.m_bIsBaked = true; if (module.GetSymWriter() != null) { SymbolToken method = new SymbolToken(this.MetadataTokenInternal); ISymbolWriter symWriter = module.GetSymWriter(); symWriter.OpenMethod(method); symWriter.OpenScope(0); if (this.m_symCustomAttrs != null) { foreach (SymCustomAttr attr in this.m_symCustomAttrs) { module.GetSymWriter().SetSymAttribute(new SymbolToken(this.MetadataTokenInternal), attr.m_name, attr.m_data); } } if (this.m_localSymInfo != null) { this.m_localSymInfo.EmitLocalSymInfo(symWriter); } il.m_ScopeTree.EmitScopeTree(symWriter); il.m_LineNumberInfo.EmitLineNumberInfo(symWriter); symWriter.CloseScope(il.ILOffset); symWriter.CloseMethod(); } }
public void CreateAssembly() { // we need to process global assembly attributes before creating assembly name _assembly_name = CreateAssemblyName(); _assembly_name.Name = Path.GetFileNameWithoutExtension(_OutputFileName); var assembly_requirements = (Manager.Options.CompileToMemory) ? Emit.AssemblyBuilderAccess.Run : Emit.AssemblyBuilderAccess.Save; var dir = Path.GetDirectoryName(Path.GetFullPath(_OutputFileName)); if (!Directory.Exists(dir)) Message.FatalError($"specified output directory `$dir' does not exist"); PermissionSet required; PermissionSet optional; PermissionSet refused; foreach ((action, perm_set) in Manager.AttributeCompiler.GetPermissionSets(assembly_attributes)) { switch (action) { case Permissions.SecurityAction.RequestMinimum: required = perm_set; break; case Permissions.SecurityAction.RequestOptional: optional = perm_set; break; case Permissions.SecurityAction.RequestRefuse: refused = perm_set; break; default: Message.FatalError($"$action is not valid here"); break; } } /* define a dynamic assembly */ this._assembly_builder = System.AppDomain.CurrentDomain.DefineDynamicAssembly (this._assembly_name, assembly_requirements, dir, required, optional, refused); GetInformationalAssemblyAttributes().Iter(this._assembly_builder.SetCustomAttribute); if (_assembly_name.Name == "") Message.FatalError("name of output assembly cannot be empty"); /* create a dynamic module */ this._module_builder = (Manager.Options.CompileToMemory) // we cannot give output filename if we are compiling only to Run ? this._assembly_builder.DefineDynamicModule(_assembly_name.Name, Manager.Options.EmitDebug) : this._assembly_builder.DefineDynamicModule(_assembly_name.Name, Path.GetFileName(_OutputFileName), Manager.Options.EmitDebug); if (Manager.Options.EmitDebug) _debug_emit = _module_builder.GetSymWriter(); }