internal LocalVariable(MetadataReader reader, LocalVariableHandle handle)
{
Debug.Assert(reader != null);
Debug.Assert(!handle.IsNil);
_reader = reader;
_rowId = handle.RowId;
}
public LocalVariableEntry(PEFile module, MetadataReader metadata, bool isEmbedded, LocalVariableHandle handle)
{
this.offset = isEmbedded ? null : (int?)metadata.GetTableMetadataOffset(TableIndex.LocalVariable)
+ metadata.GetTableRowSize(TableIndex.LocalVariable) * (MetadataTokens.GetRowNumber(handle) - 1);
this.module = module;
this.metadata = metadata;
this.handle = handle;
this.localVar = metadata.GetLocalVariable(handle);
}
internal ushort GetIndex(LocalVariableHandle handle)
{
int rowOffset = (handle.RowId - 1) * RowSize;
return(Block.PeekUInt16(rowOffset + _indexOffset));
}
internal LocalVariableAttributes GetAttributes(LocalVariableHandle handle)
{
int rowOffset = (handle.RowId - 1) * RowSize;
return((LocalVariableAttributes)Block.PeekUInt16(rowOffset + _attributesOffset));
}
private void SerializeMethodDebugInfo(IMethodBody bodyOpt, int methodRid, StandaloneSignatureHandle localSignatureHandleOpt, ref LocalVariableHandle lastLocalVariableHandle, ref LocalConstantHandle lastLocalConstantHandle)
{
if (bodyOpt == null)
{
_debugMetadataOpt.AddMethodDebugInformation(default(DocumentHandle), default(BlobHandle));
return;
}
bool isIterator = bodyOpt.StateMachineTypeName != null;
bool emitDebugInfo = isIterator || bodyOpt.HasAnySequencePoints;
if (!emitDebugInfo)
{
_debugMetadataOpt.AddMethodDebugInformation(default(DocumentHandle), default(BlobHandle));
return;
}
var methodHandle = MetadataTokens.MethodDefinitionHandle(methodRid);
var bodyImportScope = bodyOpt.ImportScope;
var importScopeHandle = (bodyImportScope != null) ? GetImportScopeIndex(bodyImportScope, _scopeIndex) : default(ImportScopeHandle);
// documents & sequence points:
DocumentHandle singleDocumentHandle;
ArrayBuilder <Cci.SequencePoint> sequencePoints = ArrayBuilder <Cci.SequencePoint> .GetInstance();
bodyOpt.GetSequencePoints(sequencePoints);
BlobHandle sequencePointsBlob = SerializeSequencePoints(localSignatureHandleOpt, sequencePoints.ToImmutableAndFree(), _documentIndex, out singleDocumentHandle);
_debugMetadataOpt.AddMethodDebugInformation(document: singleDocumentHandle, sequencePoints: sequencePointsBlob);
// Unlike native PDB we don't emit an empty root scope.
// scopes are already ordered by StartOffset ascending then by EndOffset descending (the longest scope first).
if (bodyOpt.LocalScopes.Length == 0)
{
// TODO: the compiler should produce a scope for each debuggable method
_debugMetadataOpt.AddLocalScope(
method: methodHandle,
importScope: importScopeHandle,
variableList: NextHandle(lastLocalVariableHandle),
constantList: NextHandle(lastLocalConstantHandle),
startOffset: 0,
length: bodyOpt.IL.Length);
}
else
{
foreach (LocalScope scope in bodyOpt.LocalScopes)
{
_debugMetadataOpt.AddLocalScope(
method: methodHandle,
importScope: importScopeHandle,
variableList: NextHandle(lastLocalVariableHandle),
constantList: NextHandle(lastLocalConstantHandle),
startOffset: scope.StartOffset,
length: scope.Length);
foreach (ILocalDefinition local in scope.Variables)
{
Debug.Assert(local.SlotIndex >= 0);
lastLocalVariableHandle = _debugMetadataOpt.AddLocalVariable(
attributes: local.PdbAttributes,
index: local.SlotIndex,
name: _debugMetadataOpt.GetOrAddString(local.Name));
SerializeLocalInfo(local, lastLocalVariableHandle);
}
foreach (ILocalDefinition constant in scope.Constants)
{
var mdConstant = constant.CompileTimeValue;
Debug.Assert(mdConstant != null);
lastLocalConstantHandle = _debugMetadataOpt.AddLocalConstant(
name: _debugMetadataOpt.GetOrAddString(constant.Name),
signature: SerializeLocalConstantSignature(constant));
SerializeLocalInfo(constant, lastLocalConstantHandle);
}
}
}
var asyncDebugInfo = bodyOpt.AsyncDebugInfo;
if (asyncDebugInfo != null)
{
_debugMetadataOpt.AddStateMachineMethod(
moveNextMethod: methodHandle,
kickoffMethod: GetMethodDefinitionHandle(asyncDebugInfo.KickoffMethod));
SerializeAsyncMethodSteppingInfo(asyncDebugInfo, methodHandle);
}
SerializeStateMachineLocalScopes(bodyOpt, methodHandle);
// delta doesn't need this information - we use information recorded by previous generation emit
if (Context.Module.CommonCompilation.Options.EnableEditAndContinue && !IsFullMetadata)
{
SerializeEncMethodDebugInformation(bodyOpt, methodHandle);
}
}
private static LocalVariableHandle NextHandle(LocalVariableHandle handle) => MetadataTokens.LocalVariableHandle(MetadataTokens.GetRowNumber(handle) + 1);
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);
}
}
public LocalScopeHandle AddLocalScope(MethodDefinitionHandle method, ImportScopeHandle importScope, LocalVariableHandle variableList, LocalConstantHandle constantList, int startOffset, int length)
{
_localScopeTable.Add(new LocalScopeRow
{
Method = (uint)MetadataTokens.GetRowNumber(method),
ImportScope = (uint)MetadataTokens.GetRowNumber(importScope),
VariableList = (uint)MetadataTokens.GetRowNumber(variableList),
ConstantList = (uint)MetadataTokens.GetRowNumber(constantList),
StartOffset = (uint)startOffset,
Length = (uint)length
});
return MetadataTokens.LocalScopeHandle(_localScopeTable.Count);
}
/// <summary>
/// Initializes a new instance of the <see cref="PdbLocalVariable"/> class.
/// </summary>
/// <param name="localScope">Local scope where this variable is defined.</param>
/// <param name="handle">Our metadata reader handle.</param>
public PdbLocalVariable(PdbLocalScope localScope, LocalVariableHandle handle)
{
LocalScope = localScope;
localVariableCache = SimpleCache.CreateStruct(() => LocalScope.Function.PdbFile.Reader.GetLocalVariable(handle));
nameCache = SimpleCache.CreateStruct(() => LocalScope.Function.PdbFile.Reader.GetString(LocalVariable.Name));
}
private void SerializeMethodDebugInfo(IMethodBody bodyOpt, int methodRid, int aggregateMethodRid, StandaloneSignatureHandle localSignatureHandleOpt, ref LocalVariableHandle lastLocalVariableHandle, ref LocalConstantHandle lastLocalConstantHandle)
{
if (bodyOpt == null)
{
_debugMetadataOpt.AddMethodDebugInformation(document: default, sequencePoints: default);
internal StringHandle GetName(LocalVariableHandle handle)
{
int rowOffset = (handle.RowId - 1) * RowSize;
return StringHandle.FromOffset(Block.PeekHeapReference(rowOffset + _nameOffset, _isStringHeapRefSizeSmall));
}
internal ushort GetIndex(LocalVariableHandle handle)
{
int rowOffset = (handle.RowId - 1) * RowSize;
return Block.PeekUInt16(rowOffset + _indexOffset);
}
internal LocalVariableAttributes GetAttributes(LocalVariableHandle handle)
{
int rowOffset = (handle.RowId - 1) * RowSize;
return (LocalVariableAttributes)Block.PeekUInt16(rowOffset + _attributesOffset);
}
public static LocalVariable GetLocalVariable(this LocalVariableHandle handle, MetadataReader reader) => reader.GetLocalVariable(handle);
internal StringHandle GetName(LocalVariableHandle handle)
{
int rowOffset = (handle.RowId - 1) * RowSize;
return(StringHandle.FromOffset(Block.PeekHeapReference(rowOffset + _nameOffset, _isStringHeapRefSizeSmall)));
}
public LocalVariable GetLocalVariable(LocalVariableHandle handle)
{
return new LocalVariable(this, handle);
}
internal SymVariable(SymMethod symMethod, LocalVariableHandle handle)
{
Debug.Assert(symMethod != null);
_symMethod = symMethod;
_handle = handle;
}
internal SymVariable(SymMethod symMethod, LocalVariableHandle handle)
{
Debug.Assert(symMethod != null);
_symMethod = symMethod;
_handle = handle;
}
