private static void GetAllScopes( ISymUnmanagedScope root, ArrayBuilder<ISymUnmanagedScope> allScopes, ArrayBuilder<ISymUnmanagedScope> containingScopes, int offset, bool isScopeEndInclusive) { var stack = ArrayBuilder<ISymUnmanagedScope>.GetInstance(); stack.Push(root); while (stack.Any()) { var scope = stack.Pop(); allScopes.Add(scope); if (offset >= 0 && scope.IsInScope(offset, isScopeEndInclusive)) { containingScopes.Add(scope); } foreach (var nested in scope.GetScopes()) { stack.Push(nested); } } stack.Free(); }
private static void ForEachLocalVariableRecursive( ISymUnmanagedScope scope, int offset, bool isScopeEndInclusive, Action<ISymUnmanagedVariable> action) { Debug.Assert(offset < 0 || scope.IsInScope(offset, isScopeEndInclusive)); // apply action on locals of the current scope: foreach (var local in scope.GetLocals()) { action(local); } // recurse: foreach (var child in scope.GetChildren()) { if (offset < 0 || child.IsInScope(offset, isScopeEndInclusive)) { ForEachLocalVariableRecursive(child, offset, isScopeEndInclusive, action); if (offset >= 0) { return; } } } }
internal SymScope(ISymUnmanagedScope target) { // We should not wrap null instances if (target == null) throw new ArgumentNullException("target"); m_target = target; }
internal SymbolScope(ISymUnmanagedScope unmanagedScope) { if (unmanagedScope == null) { throw new ArgumentNullException("unmanagedScope"); } this.unmanagedScope = unmanagedScope; }
public static void ValidateRange(ISymUnmanagedScope scope, int expectedStartOffset, int expectedLength) { int actualOffset; Assert.Equal(HResult.S_OK, scope.GetStartOffset(out actualOffset)); Assert.Equal(expectedStartOffset, actualOffset); Assert.Equal(HResult.S_OK, scope.GetEndOffset(out actualOffset)); Assert.Equal(expectedStartOffset + expectedLength, 2); }
public ISymbolScope[] GetChildren() { uint numScopes; scope.GetChildren(0, out numScopes, null); var unScopes = new ISymUnmanagedScope[numScopes]; scope.GetChildren((uint)unScopes.Length, out numScopes, unScopes); var scopes = new ISymbolScope[numScopes]; for (uint i = 0; i < numScopes; i++) scopes[i] = new SymbolScope(unScopes[i]); return scopes; }
private static void GetAllScopes(ISymUnmanagedScope scope, ArrayBuilder<ISymUnmanagedScope> builder, int offset, bool isScopeEndInclusive) { builder.Add(scope); foreach (var nested in scope.GetScopes()) { if ((offset < 0) || nested.IsInScope(offset, isScopeEndInclusive)) { GetAllScopes(nested, builder, offset, isScopeEndInclusive); if (offset >= 0) { return; } } } }
public int GetChildren(int cChildren, out int pcChildren, ISymUnmanagedScope[] children) { _scope.GetChildren(cChildren, out pcChildren, children); if (children != null) { for (int i = 0; i < pcChildren; i++) { children[i] = new SymScope(_reader, children[i]); } } return SymUnmanagedReaderExtensions.S_OK; }
public static ImmutableArray <ISymUnmanagedNamespace> GetNamespaces(this ISymUnmanagedScope scope) { return(ToImmutableOrEmpty(GetItems(scope, (ISymUnmanagedScope a, int b, out int c, ISymUnmanagedNamespace[] d) => a.GetNamespaces(b, out c, d)))); }
public static ISymUnmanagedMethod GetMethod(this ISymUnmanagedScope instance) { ISymUnmanagedMethod returnValue = instance.__GetMethod(); return(returnValue); }
public static ISymUnmanagedScope GetRootScope(this ISymUnmanagedMethod instance) { ISymUnmanagedScope returnValue = instance.__GetRootScope(); return(returnValue); }
// ISymUnmanagedScope public static ISymUnmanagedScope[] GetChildren(this ISymUnmanagedScope symScope) { uint count; symScope.GetChildren(0, out count, new ISymUnmanagedScope[0]); ISymUnmanagedScope[] children = new ISymUnmanagedScope[count]; symScope.GetChildren(count, out count, children); return children; }
public static ISymUnmanagedConstant[] GetAndValidateConstants(ISymUnmanagedScope scope, int expectedCount) { int count, count2; Assert.Equal(HResult.S_OK, ((ISymUnmanagedScope2)scope).GetConstants(0, out count, null)); Assert.Equal(expectedCount, count); var constants = new ISymUnmanagedConstant[count]; Assert.Equal(HResult.S_OK, ((ISymUnmanagedScope2)scope).GetConstants(count, out count2, constants)); Assert.Equal(count, count2); return constants; }
public SymbolScopeImpl(ISymUnmanagedScope scope, SymbolMethod method, SymbolScope parent) { this.scope = scope; this.method = method; this.parent = parent; }
public int GetScopeFromOffset(int offset, [MarshalAs(UnmanagedType.Interface)] out ISymUnmanagedScope scope) { // SymReader doesn't support. scope = null; return(HResult.S_OK); }
public static ImmutableArray <ISymUnmanagedConstant> GetConstants(this ISymUnmanagedScope scope) { return(ToImmutableOrEmpty(GetConstantsInternal((ISymUnmanagedScope2)scope))); }
internal SymbolScope(ISymUnmanagedScope unScope) { Contract.Requires(unScope != null); private_scope = unScope; }
private static ISymUnmanagedVariable[] GetLocalsInternal(ISymUnmanagedScope scope) { return(GetItems(scope, (ISymUnmanagedScope a, out int b) => a.GetLocalCount(out b), (ISymUnmanagedScope a, int b, out int c, ISymUnmanagedVariable[] d) => a.GetLocals(b, out c, d))); }
public static ImmutableArray <ISymUnmanagedVariable> GetLocals(this ISymUnmanagedScope scope) { return(ToImmutableOrEmpty(GetLocalsInternal(scope))); }
private static ISymUnmanagedScope[] GetScopesInternal(ISymUnmanagedScope scope) { return(GetItems(scope, (ISymUnmanagedScope a, int b, out int c, ISymUnmanagedScope[] d) => a.GetChildren(b, out c, d))); }
/// <summary> /// Emits scope debugging symbols based on <c>ISymUnmanagedScope</c> insatnce, representing /// scope from new assembly. /// </summary> /// <param name="smScope">Scope from new version of changed assembly.</param> /// <param name="placeholder">Placeholder translation for local variables.</param> public void EmitScope(ISymUnmanagedScope smScope, Dictionary<int, int> placeholder) { if(State != WriterState.Building){ throw new TranslatingException("ISym* interfaces were not initialized."); } uint scStartOffset = smScope.__GetStartOffset(); uint scEndOffset = smScope.__GetEndOffset(); mWriter.OpenScope(scStartOffset); uint localsCount = smScope.__GetLocalCount(); if(localsCount > 0){ uint read; ISymUnmanagedVariable[] variables = new ISymUnmanagedVariable[localsCount]; smScope.__GetLocals(localsCount,out read,variables); for (int i = 0; i < localsCount; i++) { byte[] signature = variables[i].GetSignature(); Signature sig = new Signature(signature); sig.Migrate(translator); signature = sig.Compress(); string name = variables[i].GetName(); uint addr1 = 0;//variables[i].GetAddressField1(); uint addr2 = 0;//variables[i].GetAddressField2(); uint addr3 = 0;//variables[i].GetAddressField3(); uint addrKind = variables[i].GetAddressKind();//variables[i].GetAddressKind(); if((variables[i].GetAttributes() & 1) != 1) { addr1 = variables[i].GetAddressField1(); addrKind = variables[i].GetAddressKind(); if (placeholder != null && placeholder.ContainsKey((int)addr1)) { addr1 = (uint)placeholder[(int)addr1]; } } uint varStartOffset = scStartOffset; uint varEndOffset = scEndOffset; uint attributes = variables[i].GetAttributes(); IntPtr pName = Marshal.StringToCoTaskMemUni(name); IntPtr pSig = Marshal.AllocCoTaskMem(signature.Length); Marshal.Copy(signature,0,pSig,signature.Length); try{ mWriter.DefineLocalVariable(pName,attributes,(uint)signature.Length,pSig,addrKind, addr1,addr2,addr3,varStartOffset,varEndOffset); } finally { Marshal.FreeCoTaskMem(pSig); Marshal.FreeCoTaskMem(pName); } } } ISymUnmanagedScope[] subScopes = smScope.GetChildren(); foreach(ISymUnmanagedScope subScope in subScopes){ EmitScope(subScope,placeholder); } mWriter.CloseScope(scEndOffset); }
int ISymUnmanagedMethod.GetRootScope(out ISymUnmanagedScope retVal) { retVal = _rootScope; return(SymUnmanagedReaderExtensions.S_OK); }
public static void ValidateRootScope(ISymUnmanagedScope scope) { int count; Assert.Equal(HResult.S_OK, scope.GetLocalCount(out count)); Assert.Equal(0, count); Assert.Equal(HResult.S_OK, ((ISymUnmanagedScope2)scope).GetConstantCount(out count)); Assert.Equal(0, count); Assert.Equal(HResult.S_OK, ((ISymUnmanagedScope2)scope).GetNamespaces(0, out count, null)); Assert.Equal(0, count); ISymUnmanagedScope parent; Assert.Equal(HResult.S_OK, scope.GetParent(out parent)); Assert.Null(parent); }
public SymbolScope(ISymUnmanagedScope scope) { this.scope = scope; }
public int GetRootScope([MarshalAs(UnmanagedType.Interface)] out ISymUnmanagedScope scope) { // SymReader always creates a new scope instance scope = new SymScope(GetRootScopeData()); return(HResult.S_OK); }
public static void GetChildren(this ISymUnmanagedScope instance, uint cChildren, out uint pcChildren, ISymUnmanagedScope[] children) { instance.__GetChildren(cChildren, out pcChildren, children); }
static ICorDebugValue _FindLocal(string name, ICorDebugILFrame ilframe, ISymUnmanagedScope unmScope, uint ip) { int varcount; unmScope.GetLocalCount(out varcount); ISymUnmanagedVariable[] vars = new ISymUnmanagedVariable[varcount]; unmScope.GetLocals(varcount, out varcount, vars); for (int iv = 0; iv < varcount; iv++) { ISymUnmanagedVariable var = vars[iv]; string varname; { int namelen; var.GetName(0, out namelen, null); StringBuilder sbName = new StringBuilder(namelen); var.GetName(sbName.Capacity, out namelen, sbName); namelen--; // Remove nul. sbName.Length = namelen; varname = sbName.ToString(); } if (name == varname) { int field1; var.GetAddressField1(out field1); ICorDebugValue pvalue; ilframe.GetLocalVariable((uint)field1, out pvalue); return pvalue; } } int cChildren; unmScope.GetChildren(0, out cChildren, null); ISymUnmanagedScope[] children = new ISymUnmanagedScope[cChildren]; unmScope.GetChildren(children.Length, out cChildren, children); for (int ic = 0; ic < cChildren; ic++) { ICorDebugValue pvalue = _FindLocal(name, ilframe, children[ic], ip); if (null != pvalue) { return pvalue; } } return null; }
public static uint GetLocalCount(this ISymUnmanagedScope instance) { return(instance.__GetLocalCount()); }
internal static void GetAllScopes(this ISymUnmanagedMethod method, ArrayBuilder <ISymUnmanagedScope> builder, int offset, bool isScopeEndInclusive) { ISymUnmanagedScope scope = method.GetRootScope(); GetAllScopes(scope, builder, offset, isScopeEndInclusive); }
internal SymScope(ISymUnmanagedScope target) { m_target = target; }
public static ISymUnmanagedScope GetScopeFromOffset(this ISymUnmanagedMethod instance, uint offset) { ISymUnmanagedScope returnValue = instance.__GetScopeFromOffset(offset); return(returnValue); }
public int GetScopeFromOffset(int offset, out ISymUnmanagedScope retVal) { throw new NotImplementedException(); }
public static ISymUnmanagedScope GetParent(this ISymUnmanagedScope instance) { ISymUnmanagedScope returnValue = instance.__GetParent(); return(returnValue); }
public static uint GetEndOffset(this ISymUnmanagedScope instance) { return(instance.__GetEndOffset()); }
public static void GetLocals(this ISymUnmanagedScope instance, uint cLocals, out uint pcLocals, ISymUnmanagedVariable[] locals) { instance.__GetLocals(cLocals, out pcLocals, locals); ProcessOutParameter(locals); }
public ISymbolScope[] GetChildren() { int count; m_target.GetChildren(0, out count, null); ISymUnmanagedScope[] uScopes = new ISymUnmanagedScope[count]; m_target.GetChildren(count, out count, uScopes); int i; ISymbolScope[] scopes = new ISymbolScope[count]; for (i = 0; i < count; i++) { scopes[i] = new SymScope(uScopes[i]); } return scopes; }
public static void GetNamespaces(this ISymUnmanagedScope instance, uint cNameSpaces, out uint pcNameSpaces, ISymUnmanagedNamespace[] namespaces) { instance.__GetNamespaces(cNameSpaces, out pcNameSpaces, namespaces); ProcessOutParameter(namespaces); }
public int GetRootScope(out ISymUnmanagedScope retVal) { _method.GetRootScope(out retVal); if (retVal != null) { retVal = new SymScope(_reader, retVal); } return SymUnmanagedReaderExtensions.S_OK; }
internal SymScope(SymReader reader, ISymUnmanagedScope scope) { _reader = reader; _scope = scope; }
private void WriteScopes(ISymUnmanagedScope scope) { writer.WriteStartElement("scope"); { writer.WriteAttributeString("startOffset", AsILOffset(scope.GetStartOffset())); writer.WriteAttributeString("endOffset", AsILOffset(scope.GetEndOffset())); { foreach (ISymUnmanagedNamespace @namespace in scope.GetNamespaces()) { WriteNamespace(@namespace); } WriteLocalsHelper(scope, slotNames: null, includeChildScopes: false); } foreach (ISymUnmanagedScope child in scope.GetScopes()) { WriteScopes(child); } } writer.WriteEndElement(); // </scope> }
public int GetParent(out ISymUnmanagedScope pRetVal) { throw new NotImplementedException(); }
private static ISymbolScope WrapRawScope(ISymUnmanagedScope rawScope) { if (ConstructorOfISymbolScope == null) { // NOTE: We have the sources for this type, so we can just make the constructor // public if reflection proves to be too expensive. var assembly = typeof(SymbolBinder).Assembly; var type = assembly.GetType("Microsoft.Samples.Debugging.CorSymbolStore.SymScope", throwOnError: true); var ctor = type.GetConstructors(BindingFlags.NonPublic | BindingFlags.Instance).Single(); Interlocked.CompareExchange(ref ConstructorOfISymbolScope, ctor, null); } return (ISymbolScope)ConstructorOfISymbolScope.Invoke(new object[] { rawScope }); }
public static void GetChildren(this ISymUnmanagedScope instance, uint cChildren, out uint pcChildren, ISymUnmanagedScope[] children) { instance.__GetChildren(cChildren, out pcChildren, children); ProcessOutParameter(children); }
// Helper method to write the local variables in the given scope. // Scopes match an IL range, and also have child scopes. private void WriteLocalsHelper(ISymUnmanagedScope rawScope, Dictionary<int, ImmutableArray<string>> slotNames, bool includeChildScopes) { WriteLocalsHelper(WrapRawScope(rawScope), slotNames, includeChildScopes); }
public static ISymUnmanagedScope[] GetAndValidateChildScopes(ISymUnmanagedScope scope, int expectedCount) { int count, count2; Assert.Equal(HResult.S_OK, scope.GetChildren(0, out count, null)); Assert.Equal(expectedCount, count); var children = new ISymUnmanagedScope[count]; Assert.Equal(HResult.S_OK, scope.GetChildren(count, out count2, children)); Assert.Equal(count, count2); return children; }
internal void GetLocalSourceNames(ISymUnmanagedScope/*!*/ scope, Hashtable/*!*/ localSourceNames) { uint numLocals = scope.GetLocalCount(); IntPtr[] localPtrs = new IntPtr[numLocals]; scope.GetLocals((uint)localPtrs.Length, out numLocals, localPtrs); char[] nameBuffer = new char[100]; uint nameLen; for (int i = 0; i < numLocals; i++) { ISymUnmanagedVariable local = (ISymUnmanagedVariable)System.Runtime.InteropServices.Marshal.GetTypedObjectForIUnknown(localPtrs[i], typeof(ISymUnmanagedVariable)); if (local != null) { local.GetName((uint)nameBuffer.Length, out nameLen, nameBuffer); int localIndex = (int)local.GetAddressField1(); localSourceNames[localIndex] = new String(nameBuffer, 0, (int)nameLen - 1); System.Runtime.InteropServices.Marshal.ReleaseComObject(local); } System.Runtime.InteropServices.Marshal.Release(localPtrs[i]); } IntPtr[] subscopes = new IntPtr[100]; uint numScopes; scope.GetChildren((uint)subscopes.Length, out numScopes, subscopes); for (int i = 0; i < numScopes; i++) { ISymUnmanagedScope subscope = (ISymUnmanagedScope)System.Runtime.InteropServices.Marshal.GetTypedObjectForIUnknown(subscopes[i], typeof(ISymUnmanagedScope)); if (subscope != null) { this.GetLocalSourceNames(subscope, localSourceNames); System.Runtime.InteropServices.Marshal.ReleaseComObject(subscope); } System.Runtime.InteropServices.Marshal.Release(subscopes[i]); //TODO: need to figure out how map these scope to blocks and set HasLocals on those blocks } }
public static ISymUnmanagedVariable[] GetAndValidateVariables(ISymUnmanagedScope scope, int expectedCount) { int count, count2, count3; Assert.Equal(HResult.S_OK, scope.GetLocalCount(out count)); Assert.Equal(expectedCount, count); Assert.Equal(HResult.S_OK, scope.GetLocals(0, out count2, null)); Assert.Equal(expectedCount, count2); var variables = new ISymUnmanagedVariable[count]; Assert.Equal(HResult.S_OK, scope.GetLocals(count, out count3, variables)); Assert.Equal(count, count3); return variables; }
// // Gather the local details in a scope and then recurse to child scopes // private void ProbeScopeForLocals(List<ILLocalVariable> variables, ISymUnmanagedScope scope) { int localCount; ThrowExceptionForHR(scope.GetLocalCount(out localCount)); ISymUnmanagedVariable[] locals = new ISymUnmanagedVariable[localCount]; ThrowExceptionForHR(scope.GetLocals(localCount, out localCount, locals)); for (int i = 0; i < localCount; i++) { var local = locals[i]; int slot; ThrowExceptionForHR(local.GetAddressField1(out slot)); int nameLength; ThrowExceptionForHR(local.GetName(0, out nameLength, null)); // nameLength includes terminating '\0' char[] nameBuffer = new char[nameLength]; ThrowExceptionForHR(local.GetName(nameLength, out nameLength, nameBuffer)); int attributes; ThrowExceptionForHR(local.GetAttributes(out attributes)); variables.Add(new ILLocalVariable() { Slot = slot, Name = new String(nameBuffer, 0, nameLength - 1), CompilerGenerated = (attributes & 0x1) != 0 }); } int childrenCount; ThrowExceptionForHR(scope.GetChildren(0, out childrenCount, null)); ISymUnmanagedScope[] children = new ISymUnmanagedScope[childrenCount]; ThrowExceptionForHR(scope.GetChildren(childrenCount, out childrenCount, children)); for (int i = 0; i < childrenCount; i++) { ProbeScopeForLocals(variables, children[i]); } }
public MockSymUnmanagedMethod(ISymUnmanagedScope rootScope) { _rootScope = rootScope; }
int ISymUnmanagedMethod.GetRootScope(out ISymUnmanagedScope retVal) { retVal = _rootScope; return(HResult.S_OK); }
int ISymUnmanagedMethod.GetScopeFromOffset(int offset, out ISymUnmanagedScope retVal) { throw new NotImplementedException(); }
static void _PrintLocals(ICorDebugILFrame ilframe, ISymUnmanagedScope unmScope, uint ip, System.IO.TextWriter writer) { int varcount; unmScope.GetLocalCount(out varcount); ISymUnmanagedVariable[] vars = new ISymUnmanagedVariable[varcount]; unmScope.GetLocals(varcount, out varcount, vars); for (int iv = 0; iv < varcount; iv++) { ISymUnmanagedVariable var = vars[iv]; string varname; { int namelen; var.GetName(0, out namelen, null); StringBuilder sbName = new StringBuilder(namelen); var.GetName(sbName.Capacity, out namelen, sbName); namelen--; // Remove nul. sbName.Length = namelen; varname = sbName.ToString(); } string valstr; { int field1; var.GetAddressField1(out field1); ICorDebugValue pvalue; ilframe.GetLocalVariable((uint)field1, out pvalue); valstr = ToString(pvalue); } writer.WriteLine("{0}={1}", varname, valstr); } int cChildren; unmScope.GetChildren(0, out cChildren, null); ISymUnmanagedScope[] children = new ISymUnmanagedScope[cChildren]; unmScope.GetChildren(children.Length, out cChildren, children); for (int ic = 0; ic < cChildren; ic++) { _PrintLocals(ilframe, children[ic], ip, writer); } }
List<DebugLocalVariableInfo> GetLocalVariablesInScope(ISymUnmanagedScope symScope) { List<DebugLocalVariableInfo> vars = new List<DebugLocalVariableInfo>(); foreach (ISymUnmanagedVariable symVar in symScope.GetLocals()) { ISymUnmanagedVariable symVarCopy = symVar; var locVarSig = new DebugSignatureReader().ReadTypeSignature(symVar.GetSignature()); DebugType locVarType = DebugType.CreateFromSignature(this.DebugModule, locVarSig, declaringType); // Compiler generated? // NB: Display class does not have the compiler-generated flag if ((symVar.GetAttributes() & 1) == 1 || symVar.GetName().StartsWith("CS$")) { // Get display class from local variable if (locVarType.IsDisplayClass) { AddCapturedLocalVariables( vars, (int)symScope.GetStartOffset(), (int)symScope.GetEndOffset(), delegate(StackFrame context) { return GetLocalVariableValue(context, symVarCopy); }, locVarType ); } } else { DebugLocalVariableInfo locVar = new DebugLocalVariableInfo( symVar.GetName(), (int)symVar.GetAddressField1(), // symVar also has Get*Offset methods, but the are not implemented (int)symScope.GetStartOffset(), (int)symScope.GetEndOffset(), locVarType, delegate(StackFrame context) { return GetLocalVariableValue(context, symVarCopy); } ); vars.Add(locVar); } } foreach(ISymUnmanagedScope childScope in symScope.GetChildren()) { vars.AddRange(GetLocalVariablesInScope(childScope)); } return vars; }
private static void SerializeScope( MetadataBuilder metadataBuilder, MetadataModel metadataModel, MethodDefinitionHandle methodHandle, ImportScopeHandle importScopeHandle, ISymUnmanagedScope symScope, Dictionary <int, DynamicLocalInfo> dynamicSlots, Dictionary <string, DynamicLocalInfo> dynamicNames, bool vbSemantics, ref LocalVariableHandle lastLocalVariableHandle, ref LocalConstantHandle lastLocalConstantHandle) { // VB Windows PDB encode the range as end-inclusive, // all Portable PDBs use end-exclusive encoding. int start = symScope.GetStartOffset(); int end = symScope.GetEndOffset() + (vbSemantics ? 1 : 0); metadataBuilder.AddLocalScope( method: methodHandle, importScope: importScopeHandle, variableList: NextHandle(lastLocalVariableHandle), constantList: NextHandle(lastLocalConstantHandle), startOffset: start, length: end - start); foreach (var symLocal in symScope.GetLocals()) { int slot = symLocal.GetSlot(); string name = symLocal.GetName(); lastLocalVariableHandle = metadataBuilder.AddLocalVariable( attributes: (LocalVariableAttributes)symLocal.GetAttributes(), index: slot, name: metadataBuilder.GetOrAddString(name)); DynamicLocalInfo dynamicInfo; if (slot > 0 && dynamicSlots.TryGetValue(slot, out dynamicInfo) || slot == 0 && dynamicNames.TryGetValue(name, out dynamicInfo)) { metadataBuilder.AddCustomDebugInformation( parent: lastLocalVariableHandle, kind: metadataBuilder.GetOrAddGuid(PortableCustomDebugInfoKinds.DynamicLocalVariables), value: SerializeDynamicLocalBlob(metadataBuilder, dynamicInfo)); } } foreach (var symConstant in symScope.GetConstants()) { string name = symConstant.GetName(); object value = symConstant.GetValue(); lastLocalConstantHandle = metadataBuilder.AddLocalConstant( name: metadataBuilder.GetOrAddString(name), signature: SerializeConstantSignature(metadataBuilder, metadataModel, symConstant.GetSignature(), value)); DynamicLocalInfo dynamicInfo; if (dynamicNames.TryGetValue(name, out dynamicInfo)) { metadataBuilder.AddCustomDebugInformation( parent: lastLocalConstantHandle, kind: metadataBuilder.GetOrAddGuid(PortableCustomDebugInfoKinds.DynamicLocalVariables), value: SerializeDynamicLocalBlob(metadataBuilder, dynamicInfo)); } } int previousChildScopeEnd = start; foreach (ISymUnmanagedScope child in symScope.GetChildren()) { int childScopeStart = child.GetStartOffset(); int childScopeEnd = child.GetEndOffset(); // scopes are properly nested: if (childScopeStart < previousChildScopeEnd || childScopeEnd > end) { // TODO: loc/warning throw new BadImageFormatException($"Invalid scope IL offset range: [{childScopeStart}, {childScopeEnd}), method 0x{MetadataTokens.GetToken(methodHandle):x}."); } previousChildScopeEnd = childScopeEnd; SerializeScope(metadataBuilder, metadataModel, methodHandle, importScopeHandle, child, dynamicSlots, dynamicNames, vbSemantics, ref lastLocalVariableHandle, ref lastLocalConstantHandle); } }