internal PEFieldSymbol(
PEModuleSymbol moduleSymbol,
PENamedTypeSymbol containingType,
FieldDefinitionHandle fieldDef)
{
Debug.Assert((object)moduleSymbol != null);
Debug.Assert((object)containingType != null);
Debug.Assert(!fieldDef.IsNil);
_handle = fieldDef;
_containingType = containingType;
try
{
moduleSymbol.Module.GetFieldDefPropsOrThrow(fieldDef, out _name, out _flags);
}
catch (BadImageFormatException)
{
if ((object)_name == null)
{
_name = String.Empty;
}
_lazyUseSiteDiagnostic = new CSDiagnosticInfo(ErrorCode.ERR_BindToBogus, this);
}
}
internal EcmaField(EcmaType type, FieldDefinitionHandle handle)
{
_type = type;
_handle = handle;
#if DEBUG
// Initialize name eagerly in debug builds for convenience
this.ToString();
#endif
}
/// <summary>
/// Returns true if the field should be imported. Visibility
/// and the value of <paramref name="importOptions"/> are considered
/// </summary>
public static bool ShouldImportField(this PEModule module, FieldDefinitionHandle field, MetadataImportOptions importOptions)
{
try
{
var flags = module.GetFieldDefFlagsOrThrow(field);
return ShouldImportField(flags, importOptions);
}
catch (BadImageFormatException)
{
return true;
}
}
protected override FieldSymbol FindFieldSymbolInType(TypeSymbol typeSymbol, FieldDefinitionHandle fieldDef)
{
Debug.Assert(typeSymbol is PENamedTypeSymbol || typeSymbol is ErrorTypeSymbol);
foreach (Symbol member in typeSymbol.GetMembersUnordered())
{
PEFieldSymbol field = member as PEFieldSymbol;
if ((object)field != null && field.Handle == fieldDef)
{
return(field);
}
}
return(null);
}
internal MetadataField(MetadataModule module, FieldDefinitionHandle handle)
{
Debug.Assert(module != null);
Debug.Assert(!handle.IsNil);
this.module = module;
this.handle = handle;
var def = module.metadata.GetFieldDefinition(handle);
this.attributes = def.Attributes;
if ((attributes & (FieldAttributes.Static | FieldAttributes.InitOnly)) != (FieldAttributes.Static | FieldAttributes.InitOnly))
{
decimalConstantState = ThreeState.False;
}
}
internal override bool TryGetFieldHandle(Cci.IFieldDefinition def, out FieldDefinitionHandle handle)
{
var other = this.mapToMetadata.MapDefinition(def) as PEFieldSymbol;
if ((object)other != null)
{
handle = other.Handle;
return(true);
}
else
{
handle = default(FieldDefinitionHandle);
return(false);
}
}
public void BlahBlahBlah()
{
var peHeader = PEHeaderBuilder.CreateLibraryHeader();
var meta = new MetadataBuilder();
var module = meta.AddModule(1,
meta.GetOrAddString("Module1"),
meta.GetOrAddGuid(Guid.Parse("11112222-3333-4444-5555-666677778888")),
meta.GetOrAddGuid(Guid.Parse("88887777-6666-5555-4444-333322221111")),
meta.GetOrAddGuid(Guid.Parse("22223333-4444-5555-6666-777788889999"))
);
var tObject = meta.AddTypeReference(
EntityHandle.ModuleDefinition,
meta.GetOrAddString("System"),
meta.GetOrAddString("Object"));
var fields = new FieldDefinitionHandle(); //EMPTY!!
var methods = new MethodDefinitionHandle(); //EMPTY!!
meta.AddTypeDefinition(
TypeAttributes.Class | TypeAttributes.Public,
meta.GetOrAddString("Namespace1"),
meta.GetOrAddString("Class1"),
tObject,
fields,
methods);
meta.GetOrAddString("Module1");
var metadataRoot = new MetadataRootBuilder(meta);
var ilBlob = new BlobBuilder();
ilBlob.WriteByte(0);
ilBlob.WriteByte(42);
var pe = new ManagedPEBuilder(peHeader, metadataRoot, ilBlob);
var blob = new BlobBuilder();
pe.Serialize(blob);
Assembly.Load(blob.ToArray());
}
public static bool ShouldImportField(
this PEModule module,
FieldDefinitionHandle field,
MetadataImportOptions importOptions
)
{
try
{
var flags = module.GetFieldDefFlagsOrThrow(field);
return(ShouldImportField(flags, importOptions));
}
catch (BadImageFormatException)
{
return(true);
}
}
private ModuleToken GetTypeToken(ModuleToken token)
{
if (token.IsNull)
{
return(token);
}
MetadataReader mdReader = token.MetadataReader;
EntityHandle handle = (EntityHandle)MetadataTokens.Handle((int)token.Token);
ModuleToken typeToken;
switch (token.TokenType)
{
case CorTokenType.mdtTypeRef:
case CorTokenType.mdtTypeDef:
typeToken = token;
break;
case CorTokenType.mdtMemberRef:
{
MemberReferenceHandle memberRefHandle = (MemberReferenceHandle)handle;
MemberReference memberRef = mdReader.GetMemberReference(memberRefHandle);
typeToken = new ModuleToken(token.Module, (mdToken)MetadataTokens.GetToken(memberRef.Parent));
}
break;
case CorTokenType.mdtFieldDef:
{
FieldDefinitionHandle fieldDefHandle = (FieldDefinitionHandle)handle;
FieldDefinition fieldDef = mdReader.GetFieldDefinition(fieldDefHandle);
typeToken = new ModuleToken(token.Module, (mdToken)MetadataTokens.GetToken(fieldDef.GetDeclaringType()));
}
break;
case CorTokenType.mdtMethodDef:
{
MethodDefinitionHandle methodDefHandle = (MethodDefinitionHandle)handle;
MethodDefinition methodDef = mdReader.GetMethodDefinition(methodDefHandle);
typeToken = new ModuleToken(token.Module, (mdToken)MetadataTokens.GetToken(methodDef.GetDeclaringType()));
}
break;
default:
throw new NotImplementedException();
}
return(typeToken);
}
private Mapping <FieldDefinitionHandle> MapFieldDefinitionImpl(FieldDefinitionHandle handle)
{
FieldDefinition fieldDefinition = _sourceMetadata.GetFieldDefinition(handle);
// Map the parent
Mapping <TypeDefinitionHandle> declaringTypeMapping = MapTypeDefinition(fieldDefinition.GetDeclaringType());
if (declaringTypeMapping.Target.IsNil)
{
return(new Mapping <FieldDefinitionHandle>());
}
string fieldName = _sourceMetadata.GetString(fieldDefinition.Name);
TypeDefinition targetDeclaringType = _targetMetadata.GetTypeDefinition(declaringTypeMapping.Target);
foreach (var targetHandle in targetDeclaringType.GetFields())
{
var targetField = _targetMetadata.GetFieldDefinition(targetHandle);
if (!_targetMetadata.StringComparer.Equals(targetField.Name, fieldName))
{
continue;
}
// The name matches. If the signature matches, return in Target; otherwise, return in CandidateTargets.
FieldSignature sourceSignature = _sourceMetadata.GetSignature(fieldDefinition);
FieldSignature targetSignature = _targetMetadata.GetSignature(targetField);
string candidateReason = CompareFieldSignatures(sourceSignature, targetSignature);
if (candidateReason == null)
{
return(new Mapping <FieldDefinitionHandle>(targetHandle));
}
var candidateTargets = ImmutableArray.Create(targetHandle);
var candidateReasons = ImmutableArray.Create(candidateReason);
return(new Mapping <FieldDefinitionHandle>(candidateTargets, candidateReasons));
}
// No field with this name was located.
return(new Mapping <FieldDefinitionHandle>());
}
/// <summary>
/// The backing field of a WinRT enumeration type is not public although the backing fields
/// of managed enumerations are. To allow managed languages to directly access this field,
/// it is made public by the metadata adapter.
/// </summary>
private uint CalculateFieldDefTreatmentAndRowId(FieldDefinitionHandle handle)
{
var flags = FieldTable.GetFlags(handle);
FieldDefTreatment treatment = FieldDefTreatment.None;
if ((flags & FieldAttributes.RTSpecialName) != 0 && StringStream.EqualsRaw(FieldTable.GetName(handle), "value__"))
{
TypeDefinitionHandle typeDef = GetDeclaringType(handle);
EntityHandle baseTypeHandle = TypeDefTable.GetExtends(typeDef);
if (baseTypeHandle.Kind == HandleKind.TypeReference)
{
var typeRef = (TypeReferenceHandle)baseTypeHandle;
if (StringStream.EqualsRaw(TypeRefTable.GetName(typeRef), "Enum") &&
StringStream.EqualsRaw(TypeRefTable.GetNamespace(typeRef), "System"))
{
treatment = FieldDefTreatment.EnumValue;
}
}
}
return(TreatmentAndRowId((byte)treatment, handle.RowId));
}
private uint GetFieldDefTreatmentAndRowId(FieldDefinitionHandle handle)
{
// PERF: This code pattern is JIT friendly and results in very efficient code.
if (this.metadataKind == MetadataKind.Ecma335)
{
return handle.RowId;
}
return CalculateFieldDefTreatmentAndRowId(handle);
}
public DefinitionField(GenericContext gc, FieldDefinitionHandle handle) : base(gc.cx)
{
this.gc = gc;
fd = cx.mdReader.GetFieldDefinition(handle);
ShortId = DeclaringType.ShortId + cx.Dot + Name;
}
public static FieldDefinition GetFieldDefinition(this FieldDefinitionHandle handle, MetadataReader reader) => reader.GetFieldDefinition(handle);
internal static RuntimeFieldInfo GetRuntimeFieldInfo(FieldDefinitionHandle fieldHandle, EcmaFormatRuntimeNamedTypeInfo definingTypeInfo, RuntimeTypeInfo contextTypeInfo, RuntimeTypeInfo reflectedType)
{
return(new EcmaFormatRuntimeFieldInfo(fieldHandle, definingTypeInfo, contextTypeInfo, reflectedType).WithDebugName());
}
internal FieldAttributes GetFlags(FieldDefinitionHandle handle)
{
int rowOffset = (handle.RowId - 1) * this.RowSize;
return (FieldAttributes)this.Block.PeekUInt16(rowOffset + _FlagsOffset);
}
/// <summary>
/// Returns field offset for given field RowId, or -1 if not available.
/// </summary>
internal int FindFieldLayoutRowId(FieldDefinitionHandle handle)
{
int rowNumber =
this.Block.BinarySearchReference(
this.NumberOfRows,
this.RowSize,
_FieldOffset,
(uint)handle.RowId,
_IsFieldTableRowRefSizeSmall);
return rowNumber + 1;
}
public DefinitionField(Context cx, FieldDefinitionHandle handle) : base(cx)
{
this.handle = handle;
fd = Context.MdReader.GetFieldDefinition(handle);
}
private static bool IsNil(FieldDefinitionHandle x) => x.IsNil;
internal MetadataFieldInfo(MetadataType type, FieldDefinitionHandle handle)
{
_type = type;
_handle = handle;
_metadata = ((MetadataAssembly)type.Assembly).Metadata;
}
private MemberInfo GetOrAddFieldInfo(FieldDefinitionHandle handle)
{
if (this.fields == null)
{
this.fields = new Dictionary<FieldDefinitionHandle, MemberInfo>();
}
MemberInfo result = null;
if (!fields.TryGetValue(handle, out result))
{
result = new MemberInfo(MemberKind.Field);
var field = metadataReader.GetFieldDefinition(handle);
result.Token = metadataReader.GetToken(handle);
result.DeclaringTypeDefinitionHandle = field.GetDeclaringType();
if (result.DeclaringTypeDefinitionHandle.IsNil)
{
throw null;
}
result.Handle = handle;
fields[handle] = result;
}
return result;
}
public Mapping<FieldDefinitionHandle> MapFieldDefinition(FieldDefinitionHandle handle)
{
return _fieldDefinitions.GetOrAdd(handle, MapFieldDefinitionImpl);
}
private void ImportFieldDefinitionAccessories(FieldDefinitionHandle srcHandle, FieldDefinitionHandle dstHandle)
{
var src = _reader.GetFieldDefinition(srcHandle);
using var _ = WithLogPrefix($"[{_reader.ToString(src)}]");
if (!src.GetDefaultValue().IsNil)
{
var srcConst = _reader.GetConstant(src.GetDefaultValue());
var value = _reader.GetBlobReader(srcConst.Value).ReadConstant(srcConst.TypeCode);
var dstConst = _builder.AddConstant(dstHandle, value);
Trace?.Invoke($"Imported default value {_reader.ToString(srcConst)} -> {RowId(dstConst):X} = {value}");
}
if (!src.GetMarshallingDescriptor().IsNil)
{
_builder.AddMarshallingDescriptor(dstHandle, ImportValue(src.GetMarshallingDescriptor()));
Trace?.Invoke($"Imported marshalling descriptor {_reader.ToString(src.GetMarshallingDescriptor())}");
}
if (src.GetOffset() != -1)
{
_builder.AddFieldLayout(dstHandle, src.GetOffset());
Trace?.Invoke($"Imported offset {src.GetOffset()}");
}
if (src.GetRelativeVirtualAddress() != 0)
{
_builder.AddFieldRelativeVirtualAddress(dstHandle, src.GetRelativeVirtualAddress());
Trace?.Invoke($"Imported relative virtual address {src.GetRelativeVirtualAddress()}");
}
}
public static int GetToken(this FieldDefinitionHandle handle) => MetadataTokens.GetToken(handle);
internal BlobHandle GetSignature(FieldDefinitionHandle handle)
{
int rowOffset = (int)(handle.RowId - 1) * this.RowSize;
return BlobHandle.FromIndex(this.Block.PeekReference(rowOffset + this.SignatureOffset, this.IsBlobHeapRefSizeSmall));
}
public Field ParseField(FieldDefinitionHandle handle)
{
var ret = new Field();
var fieldDef = Reader.GetFieldDefinition(handle);
ret.Signature = ILReader.ParseFieldSignature(this, Reader.GetBlobBytes(fieldDef.Signature));
ret.Name = Reader.GetString(fieldDef.Name);
var defaultHandle = fieldDef.GetDefaultValue();
if (defaultHandle.IsNil)
ret.DefaultValue = new Program.Constant(ret.Signature.Type, null);
else
ret.DefaultValue = ParseConstant(fieldDef.GetDefaultValue());
var parent = GetClassImmediate(MetadataTokens.GetToken(fieldDef.GetDeclaringType()));
if (fieldDef.Attributes.HasFlag(FieldAttributes.Static))
parent.StaticFields.AddUnique(ret.Name, ret);
else
parent.InstanceFields.AddUnique(ret.Name, ret);
return ret;
}
public Mapping <FieldDefinitionHandle> MapFieldDefinition(FieldDefinitionHandle handle)
{
return(_fieldDefinitions.GetOrAdd(handle, MapFieldDefinitionImpl));
}
public bool HasAttribute(MetadataReader reader, FieldDefinitionHandle typeHandle, string attributeFullName) => HasAttribute(reader, reader.GetFieldDefinition(typeHandle), attributeFullName);
public static bool HasGeneratedName(this FieldDefinitionHandle handle, MetadataReader metadata)
{
return(metadata.GetFieldDefinition(handle).Name.IsGeneratedName(metadata));
}
internal StringHandle GetName(FieldDefinitionHandle handle)
{
int rowOffset = (handle.RowId - 1) * this.RowSize;
return StringHandle.FromOffset(this.Block.PeekHeapReference(rowOffset + _NameOffset, _IsStringHeapRefSizeSmall));
}
private FieldAndOffset[] CreateDynamicLayout(DefType defType, EcmaModule module)
{
List <FieldAndOffset> fieldsForType = null;
int pointerSize = module.Context.Target.PointerSize;
// In accordance with CoreCLR runtime conventions,
// index 0 corresponds to regular statics, index 1 to thread-local statics.
int[][] nonGcStaticsCount = new int[StaticIndexCount][]
{
new int[TargetDetails.MaximumLog2PrimitiveSize + 1],
new int[TargetDetails.MaximumLog2PrimitiveSize + 1],
};
int[] gcPointerCount = new int[StaticIndexCount];
int[] gcBoxedCount = new int[StaticIndexCount];
foreach (FieldDesc field in defType.GetFields())
{
FieldDefinition fieldDef = module.MetadataReader.GetFieldDefinition(((EcmaField)field.GetTypicalFieldDefinition()).Handle);
if ((fieldDef.Attributes & (FieldAttributes.Static | FieldAttributes.Literal)) == FieldAttributes.Static)
{
int index = (IsFieldThreadStatic(in fieldDef, module.MetadataReader) ? StaticIndexThreadLocal : StaticIndexRegular);
int alignment;
int size;
bool isGcPointerField;
bool isGcBoxedField;
CorElementType corElementType;
EntityHandle valueTypeHandle;
GetFieldElementTypeAndValueTypeHandle(in fieldDef, module.MetadataReader, out corElementType, out valueTypeHandle);
GetElementTypeInfo(module, field, valueTypeHandle, corElementType, pointerSize, out alignment, out size, out isGcPointerField, out isGcBoxedField);
if (isGcPointerField)
{
gcPointerCount[index]++;
}
else if (isGcBoxedField)
{
gcBoxedCount[index]++;
}
if (size != 0)
{
int log2Size = GetLog2Size(size);
nonGcStaticsCount[index][log2Size]++;
}
}
}
int nonGcInitialOffset;
switch (pointerSize)
{
case 4:
nonGcInitialOffset = DomainLocalModuleNormalDynamicEntryOffsetOfDataBlob32Bit;
break;
case 8:
nonGcInitialOffset = DomainLocalModuleNormalDynamicEntryOffsetOfDataBlob64Bit;
break;
default:
throw new NotImplementedException();
}
LayoutInt[] nonGcStaticFieldOffsets = new LayoutInt[StaticIndexCount]
{
new LayoutInt(nonGcInitialOffset),
new LayoutInt(nonGcInitialOffset),
};
LayoutInt[][] nonGcStatics = new LayoutInt[StaticIndexCount][]
{
new LayoutInt[TargetDetails.MaximumLog2PrimitiveSize + 1],
new LayoutInt[TargetDetails.MaximumLog2PrimitiveSize + 1],
};
for (int log2Size = TargetDetails.MaximumLog2PrimitiveSize; log2Size >= 0; log2Size--)
{
for (int index = 0; index < StaticIndexCount; index++)
{
LayoutInt offset = nonGcStaticFieldOffsets[index];
nonGcStatics[index][log2Size] = offset;
offset += new LayoutInt(nonGcStaticsCount[index][log2Size] << log2Size);
nonGcStaticFieldOffsets[index] = offset;
}
}
LayoutInt[] gcBoxedFieldOffsets = new LayoutInt[StaticIndexCount];
LayoutInt[] gcPointerFieldOffsets = new LayoutInt[StaticIndexCount]
{
new LayoutInt(gcBoxedCount[StaticIndexRegular] * pointerSize),
new LayoutInt(gcBoxedCount[StaticIndexThreadLocal] * pointerSize)
};
foreach (FieldDesc field in defType.GetFields())
{
FieldDefinitionHandle fieldDefHandle = ((EcmaField)field.GetTypicalFieldDefinition()).Handle;
FieldDefinition fieldDef = module.MetadataReader.GetFieldDefinition(fieldDefHandle);
if ((fieldDef.Attributes & (FieldAttributes.Static | FieldAttributes.Literal)) == FieldAttributes.Static)
{
int index = (IsFieldThreadStatic(in fieldDef, module.MetadataReader) ? StaticIndexThreadLocal : StaticIndexRegular);
int alignment;
int size;
bool isGcPointerField;
bool isGcBoxedField;
CorElementType corElementType;
EntityHandle valueTypeHandle;
GetFieldElementTypeAndValueTypeHandle(in fieldDef, module.MetadataReader, out corElementType, out valueTypeHandle);
GetElementTypeInfo(module, field, valueTypeHandle, corElementType, pointerSize, out alignment, out size, out isGcPointerField, out isGcBoxedField);
LayoutInt offset = LayoutInt.Zero;
if (size != 0)
{
int log2Size = GetLog2Size(size);
offset = nonGcStatics[index][log2Size];
nonGcStatics[index][log2Size] += new LayoutInt(1 << log2Size);
}
if (isGcPointerField)
{
offset = gcPointerFieldOffsets[index];
gcPointerFieldOffsets[index] += new LayoutInt(pointerSize);
}
else if (isGcBoxedField)
{
offset = gcBoxedFieldOffsets[index];
gcBoxedFieldOffsets[index] += new LayoutInt(pointerSize);
}
if (fieldsForType == null)
{
fieldsForType = new List <FieldAndOffset>();
}
fieldsForType.Add(new FieldAndOffset(field, offset));
}
}
return(fieldsForType == null ? null : fieldsForType.ToArray());
}
internal BlobHandle GetSignature(FieldDefinitionHandle handle)
{
int rowOffset = (handle.RowId - 1) * this.RowSize;
return BlobHandle.FromOffset(this.Block.PeekHeapReference(rowOffset + _SignatureOffset, _IsBlobHeapRefSizeSmall));
}
protected override IEntityHandleObject CreateValueFromKey(EntityHandle handle)
{
object item;
switch (handle.Kind)
{
case HandleKind.TypeDefinition:
item = new EcmaType(_module, (TypeDefinitionHandle)handle);
break;
case HandleKind.MethodDefinition:
{
MethodDefinitionHandle methodDefinitionHandle = (MethodDefinitionHandle)handle;
TypeDefinitionHandle typeDefinitionHandle = _module._metadataReader.GetMethodDefinition(methodDefinitionHandle).GetDeclaringType();
EcmaType type = (EcmaType)_module.GetObject(typeDefinitionHandle);
item = new EcmaMethod(type, methodDefinitionHandle);
}
break;
case HandleKind.FieldDefinition:
{
FieldDefinitionHandle fieldDefinitionHandle = (FieldDefinitionHandle)handle;
TypeDefinitionHandle typeDefinitionHandle = _module._metadataReader.GetFieldDefinition(fieldDefinitionHandle).GetDeclaringType();
EcmaType type = (EcmaType)_module.GetObject(typeDefinitionHandle);
item = new EcmaField(type, fieldDefinitionHandle);
}
break;
case HandleKind.TypeReference:
item = _module.ResolveTypeReference((TypeReferenceHandle)handle);
break;
case HandleKind.MemberReference:
item = _module.ResolveMemberReference((MemberReferenceHandle)handle);
break;
case HandleKind.AssemblyReference:
item = _module.ResolveAssemblyReference((AssemblyReferenceHandle)handle);
break;
case HandleKind.TypeSpecification:
item = _module.ResolveTypeSpecification((TypeSpecificationHandle)handle);
break;
case HandleKind.MethodSpecification:
item = _module.ResolveMethodSpecification((MethodSpecificationHandle)handle);
break;
case HandleKind.ExportedType:
item = _module.ResolveExportedType((ExportedTypeHandle)handle);
break;
case HandleKind.StandaloneSignature:
item = _module.ResolveStandaloneSignature((StandaloneSignatureHandle)handle);
break;
case HandleKind.ModuleDefinition:
// ECMA-335 Partition 2 II.22.38 1d: This should not occur in a CLI ("compressed metadata") module,
// but resolves to "current module".
item = _module;
break;
default:
throw new BadImageFormatException("Unknown metadata token type: " + handle.Kind);
}
switch (handle.Kind)
{
case HandleKind.TypeDefinition:
case HandleKind.MethodDefinition:
case HandleKind.FieldDefinition:
// type/method/field definitions directly correspond to their target item.
return((IEntityHandleObject)item);
default:
// Everything else is some form of reference which cannot be self-describing
return(new EcmaObjectLookupWrapper(handle, item));
}
}
public void AddFieldLayout(
FieldDefinitionHandle field,
int offset)
{
_fieldLayoutTable.Add(new FieldLayoutRow
{
Field = (uint)MetadataTokens.GetRowNumber(field),
Offset = (uint)offset
});
}
public static FieldDefinition GetFieldDefinition(MetadataReader reader, FieldDefinitionHandle handle)
{
return(reader.GetFieldDefinition(handle));
}
public static bool IsCompilerGenerated(this FieldDefinitionHandle handle, MetadataReader metadata)
{
return(metadata.GetFieldDefinition(handle).IsCompilerGenerated(metadata));
}
protected override IEntityHandleObject CreateValueFromKey(EntityHandle handle)
{
object item;
switch (handle.Kind)
{
case HandleKind.TypeDefinition:
item = new EcmaType(_module, (TypeDefinitionHandle)handle);
break;
case HandleKind.MethodDefinition:
{
MethodDefinitionHandle methodDefinitionHandle = (MethodDefinitionHandle)handle;
TypeDefinitionHandle typeDefinitionHandle = _module._metadataReader.GetMethodDefinition(methodDefinitionHandle).GetDeclaringType();
EcmaType type = (EcmaType)_module.GetObject(typeDefinitionHandle);
item = new EcmaMethod(type, methodDefinitionHandle);
}
break;
case HandleKind.FieldDefinition:
{
FieldDefinitionHandle fieldDefinitionHandle = (FieldDefinitionHandle)handle;
TypeDefinitionHandle typeDefinitionHandle = _module._metadataReader.GetFieldDefinition(fieldDefinitionHandle).GetDeclaringType();
EcmaType type = (EcmaType)_module.GetObject(typeDefinitionHandle);
item = new EcmaField(type, fieldDefinitionHandle);
}
break;
case HandleKind.TypeReference:
item = _module.ResolveTypeReference((TypeReferenceHandle)handle);
break;
case HandleKind.MemberReference:
item = _module.ResolveMemberReference((MemberReferenceHandle)handle);
break;
case HandleKind.AssemblyReference:
item = _module.ResolveAssemblyReference((AssemblyReferenceHandle)handle);
break;
case HandleKind.TypeSpecification:
item = _module.ResolveTypeSpecification((TypeSpecificationHandle)handle);
break;
case HandleKind.MethodSpecification:
item = _module.ResolveMethodSpecification((MethodSpecificationHandle)handle);
break;
case HandleKind.ExportedType:
item = _module.ResolveExportedType((ExportedTypeHandle)handle);
break;
// TODO: Resolve other tokens
default:
throw new BadImageFormatException("Unknown metadata token type");
}
switch (handle.Kind)
{
case HandleKind.TypeDefinition:
case HandleKind.MethodDefinition:
case HandleKind.FieldDefinition:
// type/method/field definitions directly correspond to their target item.
return((IEntityHandleObject)item);
default:
// Everything else is some form of reference which cannot be self-describing
return(new EcmaObjectLookupWrapper(handle, item));
}
}
internal abstract bool TryGetFieldHandle(Cci.IFieldDefinition def, out FieldDefinitionHandle handle);
/// <summary>
/// The backing field of a WinRT enumeration type is not public although the backing fields
/// of managed enumerations are. To allow managed languages to directly access this field,
/// it is made public by the metadata adapter.
/// </summary>
private uint CalculateFieldDefTreatmentAndRowId(FieldDefinitionHandle handle)
{
var flags = FieldTable.GetFlags(handle);
FieldDefTreatment treatment = FieldDefTreatment.None;
if ((flags & FieldAttributes.RTSpecialName) != 0 && StringStream.EqualsRaw(FieldTable.GetName(handle), "value__"))
{
TypeDefinitionHandle typeDef = GetDeclaringType(handle);
EntityHandle baseTypeHandle = TypeDefTable.GetExtends(typeDef);
if (baseTypeHandle.Kind == HandleKind.TypeReference)
{
var typeRef = (TypeReferenceHandle)baseTypeHandle;
if (StringStream.EqualsRaw(TypeRefTable.GetName(typeRef), "Enum") &&
StringStream.EqualsRaw(TypeRefTable.GetNamespace(typeRef), "System"))
{
treatment = FieldDefTreatment.EnumValue;
}
}
}
return TreatmentAndRowId((byte)treatment, handle.RowId);
}
public TypeDefinitionHandle AddTypeDefinition(
TypeAttributes attributes,
StringHandle @namespace,
StringHandle name,
EntityHandle baseType,
FieldDefinitionHandle fieldList,
MethodDefinitionHandle methodList)
{
Debug.Assert(@namespace != null);
Debug.Assert(name != null);
_typeDefTable.Add(new TypeDefRow
{
Flags = (uint)attributes,
Name = name,
Namespace = @namespace,
Extends = baseType.IsNil ? 0 : (uint)CodedIndex.ToTypeDefOrRef(baseType),
FieldList = (uint)MetadataTokens.GetRowNumber(fieldList),
MethodList = (uint)MetadataTokens.GetRowNumber(methodList)
});
return MetadataTokens.TypeDefinitionHandle(_typeDefTable.Count);
}
public FieldDefinition GetFieldDefinition(FieldDefinitionHandle handle)
{
// PERF: This code pattern is JIT friendly and results in very efficient code.
return new FieldDefinition(this, GetFieldDefTreatmentAndRowId(handle));
}
public void AddFieldRelativeVirtualAddress(
FieldDefinitionHandle field,
int relativeVirtualAddress)
{
_fieldRvaTable.Add(new FieldRvaRow
{
Field = (uint)MetadataTokens.GetRowNumber(field),
Offset = (uint)relativeVirtualAddress
});
}
private Mapping<FieldDefinitionHandle> MapFieldDefinitionImpl(FieldDefinitionHandle handle)
{
FieldDefinition fieldDefinition = _sourceMetadata.GetFieldDefinition(handle);
// Map the parent
Mapping<TypeDefinitionHandle> declaringTypeMapping = MapTypeDefinition(fieldDefinition.GetDeclaringType());
if (declaringTypeMapping.Target.IsNil)
return new Mapping<FieldDefinitionHandle>();
string fieldName = _sourceMetadata.GetString(fieldDefinition.Name);
TypeDefinition targetDeclaringType = _targetMetadata.GetTypeDefinition(declaringTypeMapping.Target);
foreach (var targetHandle in targetDeclaringType.GetFields())
{
var targetField = _targetMetadata.GetFieldDefinition(targetHandle);
if (!_targetMetadata.StringComparer.Equals(targetField.Name, fieldName))
continue;
// The name matches. If the signature matches, return in Target; otherwise, return in CandidateTargets.
FieldSignature sourceSignature = _sourceMetadata.GetSignature(fieldDefinition);
FieldSignature targetSignature = _targetMetadata.GetSignature(targetField);
string candidateReason = CompareFieldSignatures(sourceSignature, targetSignature);
if (candidateReason == null)
return new Mapping<FieldDefinitionHandle>(targetHandle);
var candidateTargets = ImmutableArray.Create(targetHandle);
var candidateReasons = ImmutableArray.Create(candidateReason);
return new Mapping<FieldDefinitionHandle>(candidateTargets, candidateReasons);
}
// No field with this name was located.
return new Mapping<FieldDefinitionHandle>();
}
public DefinitionField(GenericContext gc, FieldDefinitionHandle handle) : base(gc.cx)
{
this.handle = handle;
this.gc = gc;
fd = cx.mdReader.GetFieldDefinition(handle);
}
public static string ToString(this MetadataReader reader, FieldDefinitionHandle x) => reader.ToString(reader.GetFieldDefinition(x));
internal abstract bool TryGetFieldHandle(Cci.IFieldDefinition def, out FieldDefinitionHandle handle);
public unsafe FieldRVA(byte *ptr, int fieldDefSize)
{
Offset = Helpers.GetValue(ptr, 4);
Field = MetadataTokens.FieldDefinitionHandle(Helpers.GetValue(ptr + 4, fieldDefSize));
}
internal TypeDefinitionHandle GetDeclaringType(FieldDefinitionHandle fieldDef)
{
uint fieldRowId;
if (UseFieldPtrTable)
{
fieldRowId = FieldPtrTable.GetRowIdForFieldDefRow(fieldDef.RowId);
}
else
{
fieldRowId = fieldDef.RowId;
}
return TypeDefTable.FindTypeContainingField(fieldRowId, (int)FieldTable.NumberOfRows);
}
private static FlowAnalysisAnnotations DecodeFlowAnalysisAttributes(PEModule module, FieldDefinitionHandle handle)
{
FlowAnalysisAnnotations annotations = FlowAnalysisAnnotations.None;
if (module.HasAttribute(handle, AttributeDescription.AllowNullAttribute))
{
annotations |= FlowAnalysisAnnotations.AllowNull;
}
if (module.HasAttribute(handle, AttributeDescription.DisallowNullAttribute))
{
annotations |= FlowAnalysisAnnotations.DisallowNull;
}
if (module.HasAttribute(handle, AttributeDescription.MaybeNullAttribute))
{
annotations |= FlowAnalysisAnnotations.MaybeNull;
}
if (module.HasAttribute(handle, AttributeDescription.NotNullAttribute))
{
annotations |= FlowAnalysisAnnotations.NotNull;
}
return(annotations);
}
public void IsNil()
{
Assert.False(ModuleDefinitionHandle.FromRowId(1).IsNil);
Assert.False(AssemblyDefinitionHandle.FromRowId(1).IsNil);
Assert.False(InterfaceImplementationHandle.FromRowId(1).IsNil);
Assert.False(MethodDefinitionHandle.FromRowId(1).IsNil);
Assert.False(MethodSpecificationHandle.FromRowId(1).IsNil);
Assert.False(TypeDefinitionHandle.FromRowId(1).IsNil);
Assert.False(ExportedTypeHandle.FromRowId(1).IsNil);
Assert.False(TypeReferenceHandle.FromRowId(1).IsNil);
Assert.False(TypeSpecificationHandle.FromRowId(1).IsNil);
Assert.False(MemberReferenceHandle.FromRowId(1).IsNil);
Assert.False(FieldDefinitionHandle.FromRowId(1).IsNil);
Assert.False(EventDefinitionHandle.FromRowId(1).IsNil);
Assert.False(PropertyDefinitionHandle.FromRowId(1).IsNil);
Assert.False(StandaloneSignatureHandle.FromRowId(1).IsNil);
Assert.False(MemberReferenceHandle.FromRowId(1).IsNil);
Assert.False(FieldDefinitionHandle.FromRowId(1).IsNil);
Assert.False(EventDefinitionHandle.FromRowId(1).IsNil);
Assert.False(PropertyDefinitionHandle.FromRowId(1).IsNil);
Assert.False(ParameterHandle.FromRowId(1).IsNil);
Assert.False(GenericParameterHandle.FromRowId(1).IsNil);
Assert.False(GenericParameterConstraintHandle.FromRowId(1).IsNil);
Assert.False(ModuleReferenceHandle.FromRowId(1).IsNil);
Assert.False(CustomAttributeHandle.FromRowId(1).IsNil);
Assert.False(DeclarativeSecurityAttributeHandle.FromRowId(1).IsNil);
Assert.False(ManifestResourceHandle.FromRowId(1).IsNil);
Assert.False(ConstantHandle.FromRowId(1).IsNil);
Assert.False(ManifestResourceHandle.FromRowId(1).IsNil);
Assert.False(AssemblyFileHandle.FromRowId(1).IsNil);
Assert.False(MethodImplementationHandle.FromRowId(1).IsNil);
Assert.False(AssemblyReferenceHandle.FromRowId(1).IsNil);
Assert.False(((EntityHandle)ModuleDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)AssemblyDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)InterfaceImplementationHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)MethodDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)MethodSpecificationHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)TypeDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)ExportedTypeHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)TypeReferenceHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)TypeSpecificationHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)MemberReferenceHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)FieldDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)EventDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)PropertyDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)StandaloneSignatureHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)MemberReferenceHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)FieldDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)EventDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)PropertyDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)ParameterHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)GenericParameterHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)GenericParameterConstraintHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)ModuleReferenceHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)CustomAttributeHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)DeclarativeSecurityAttributeHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)ManifestResourceHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)ConstantHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)ManifestResourceHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)AssemblyFileHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)MethodImplementationHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)AssemblyReferenceHandle.FromRowId(1)).IsNil);
Assert.False(StringHandle.FromOffset(1).IsNil);
Assert.False(BlobHandle.FromOffset(1).IsNil);
Assert.False(UserStringHandle.FromOffset(1).IsNil);
Assert.False(GuidHandle.FromIndex(1).IsNil);
Assert.False(((Handle)StringHandle.FromOffset(1)).IsNil);
Assert.False(((Handle)BlobHandle.FromOffset(1)).IsNil);
Assert.False(((Handle)UserStringHandle.FromOffset(1)).IsNil);
Assert.False(((Handle)GuidHandle.FromIndex(1)).IsNil);
Assert.True(ModuleDefinitionHandle.FromRowId(0).IsNil);
Assert.True(AssemblyDefinitionHandle.FromRowId(0).IsNil);
Assert.True(InterfaceImplementationHandle.FromRowId(0).IsNil);
Assert.True(MethodDefinitionHandle.FromRowId(0).IsNil);
Assert.True(MethodSpecificationHandle.FromRowId(0).IsNil);
Assert.True(TypeDefinitionHandle.FromRowId(0).IsNil);
Assert.True(ExportedTypeHandle.FromRowId(0).IsNil);
Assert.True(TypeReferenceHandle.FromRowId(0).IsNil);
Assert.True(TypeSpecificationHandle.FromRowId(0).IsNil);
Assert.True(MemberReferenceHandle.FromRowId(0).IsNil);
Assert.True(FieldDefinitionHandle.FromRowId(0).IsNil);
Assert.True(EventDefinitionHandle.FromRowId(0).IsNil);
Assert.True(PropertyDefinitionHandle.FromRowId(0).IsNil);
Assert.True(StandaloneSignatureHandle.FromRowId(0).IsNil);
Assert.True(MemberReferenceHandle.FromRowId(0).IsNil);
Assert.True(FieldDefinitionHandle.FromRowId(0).IsNil);
Assert.True(EventDefinitionHandle.FromRowId(0).IsNil);
Assert.True(PropertyDefinitionHandle.FromRowId(0).IsNil);
Assert.True(ParameterHandle.FromRowId(0).IsNil);
Assert.True(GenericParameterHandle.FromRowId(0).IsNil);
Assert.True(GenericParameterConstraintHandle.FromRowId(0).IsNil);
Assert.True(ModuleReferenceHandle.FromRowId(0).IsNil);
Assert.True(CustomAttributeHandle.FromRowId(0).IsNil);
Assert.True(DeclarativeSecurityAttributeHandle.FromRowId(0).IsNil);
Assert.True(ManifestResourceHandle.FromRowId(0).IsNil);
Assert.True(ConstantHandle.FromRowId(0).IsNil);
Assert.True(ManifestResourceHandle.FromRowId(0).IsNil);
Assert.True(AssemblyFileHandle.FromRowId(0).IsNil);
Assert.True(MethodImplementationHandle.FromRowId(0).IsNil);
Assert.True(AssemblyReferenceHandle.FromRowId(0).IsNil);
Assert.True(((EntityHandle)ModuleDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)AssemblyDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)InterfaceImplementationHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)MethodDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)MethodSpecificationHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)TypeDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)ExportedTypeHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)TypeReferenceHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)TypeSpecificationHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)MemberReferenceHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)FieldDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)EventDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)PropertyDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)StandaloneSignatureHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)MemberReferenceHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)FieldDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)EventDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)PropertyDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)ParameterHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)GenericParameterHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)GenericParameterConstraintHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)ModuleReferenceHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)CustomAttributeHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)DeclarativeSecurityAttributeHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)ManifestResourceHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)ConstantHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)ManifestResourceHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)AssemblyFileHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)MethodImplementationHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)AssemblyReferenceHandle.FromRowId(0)).IsNil);
// heaps:
Assert.True(StringHandle.FromOffset(0).IsNil);
Assert.True(BlobHandle.FromOffset(0).IsNil);
Assert.True(UserStringHandle.FromOffset(0).IsNil);
Assert.True(GuidHandle.FromIndex(0).IsNil);
Assert.True(((Handle)StringHandle.FromOffset(0)).IsNil);
Assert.True(((Handle)BlobHandle.FromOffset(0)).IsNil);
Assert.True(((Handle)UserStringHandle.FromOffset(0)).IsNil);
Assert.True(((Handle)GuidHandle.FromIndex(0)).IsNil);
// virtual:
Assert.False(AssemblyReferenceHandle.FromVirtualIndex(0).IsNil);
Assert.False(StringHandle.FromVirtualIndex(0).IsNil);
Assert.False(BlobHandle.FromVirtualIndex(0, 0).IsNil);
Assert.False(((Handle)AssemblyReferenceHandle.FromVirtualIndex(0)).IsNil);
Assert.False(((Handle)StringHandle.FromVirtualIndex(0)).IsNil);
Assert.False(((Handle)BlobHandle.FromVirtualIndex(0, 0)).IsNil);
}
internal StringHandle GetName(FieldDefinitionHandle handle)
{
int rowOffset = (int)(handle.RowId - 1) * this.RowSize;
return StringHandle.FromIndex(this.Block.PeekReference(rowOffset + this.NameOffset, this.IsStringHeapRefSizeSmall));
}
