private BlobHandle GetFieldSignatureBlobHandle(FieldDesc field)
{
var fieldDef = field.GetTypicalFieldDefinition();
var embeddedSigData = field.GetEmbeddedSignatureData();
EmbeddedSignatureDataEmitter signatureDataEmitter;
if (embeddedSigData != null && embeddedSigData.Length != 0)
{
signatureDataEmitter = new EmbeddedSignatureDataEmitter(embeddedSigData, this);
}
else
{
signatureDataEmitter = EmbeddedSignatureDataEmitter.EmptySingleton;
}
BlobBuilder memberRefSig = new BlobBuilder();
EncodeFieldSignature(memberRefSig, field.FieldType, signatureDataEmitter);
if (!signatureDataEmitter.Complete)
{
throw new ArgumentException();
}
var sigBlob = _metadataBuilder.GetOrAddBlob(memberRefSig);
return(sigBlob);
}
private void InitializeFieldReference(Cts.FieldDesc entity, MemberReference record)
{
record.Name = HandleString(entity.Name);
record.Parent = HandleType(entity.OwningType);
record.Signature = new FieldSignature
{
Type = HandleType(entity.GetTypicalFieldDefinition().FieldType),
// TODO: CustomModifiers
};
}
/// <summary>
/// Creates an open instantiation of a field. Given Foo<T>.Field, returns
/// Foo<!0>.Field. If the owning type is not generic, returns the <paramref name="field"/>.
/// </summary>
public static FieldDesc InstantiateAsOpen(this FieldDesc field)
{
Debug.Assert(field.GetTypicalFieldDefinition() == field);
TypeDesc owner = field.OwningType;
if (owner.HasInstantiation)
{
var instantiatedOwner = (InstantiatedType)owner.InstantiateAsOpen();
return(field.Context.GetFieldForInstantiatedType(field, instantiatedOwner));
}
return(field);
}
public override MetadataRecord HandleQualifiedField(Cts.FieldDesc field)
{
if (_policy.GeneratesMetadata(field) && field.GetTypicalFieldDefinition() == field)
{
QualifiedField record = new QualifiedField();
record.Field = HandleFieldDefinition(field);
record.EnclosingType = (TypeDefinition)HandleType(field.OwningType);
return(record);
}
else
{
return(HandleFieldReference(field));
}
}
public virtual FieldDesc InstantiateSignature(Instantiation typeInstantiation, Instantiation methodInstantiation)
{
FieldDesc field = this;
TypeDesc owningType = field.OwningType;
TypeDesc instantiatedOwningType = owningType.InstantiateSignature(typeInstantiation, methodInstantiation);
if (owningType != instantiatedOwningType)
{
field = instantiatedOwningType.Context.GetFieldForInstantiatedType(field.GetTypicalFieldDefinition(), (InstantiatedType)instantiatedOwningType);
}
return(field);
}
/// <summary>
/// Gets an object representing the static data for RVA mapped fields from the PE image.
/// </summary>
public ObjectNode GetFieldRvaData(FieldDesc field)
{
if (field.GetType() == typeof(Internal.IL.Stubs.PInvokeLazyFixupField))
{
var pInvokeFixup = (Internal.IL.Stubs.PInvokeLazyFixupField)field;
PInvokeMetadata metadata = pInvokeFixup.PInvokeMetadata;
return NodeFactory.PInvokeMethodFixup(metadata.Module, metadata.Name);
}
else
{
// Use the typical field definition in case this is an instantiated generic type
field = field.GetTypicalFieldDefinition();
return NodeFactory.ReadOnlyDataBlob(NameMangler.GetMangledFieldName(field),
((EcmaField)field).GetFieldRvaData(), NodeFactory.Target.PointerSize);
}
}
public EntityHandle GetFieldRef(FieldDesc field)
{
if (_fieldRefs.TryGetValue(field, out var handle))
{
return(handle);
}
EntityHandle fieldHandle;
EntityHandle typeHandle = GetTypeRef((MetadataType)field.OwningType);
StringHandle fieldName = _metadataBuilder.GetOrAddString(field.Name);
var sigBlob = GetFieldSignatureBlobHandle(field.GetTypicalFieldDefinition());
fieldHandle = _metadataBuilder.AddMemberReference(typeHandle, fieldName, sigBlob);
_fieldRefs.Add(field, fieldHandle);
return(fieldHandle);
}
private Field HandleFieldDefinition(Cts.FieldDesc field)
{
Debug.Assert(field.GetTypicalFieldDefinition() == field);
Debug.Assert(_policy.GeneratesMetadata(field));
return((Field)_fields.GetOrCreate(field, _initFieldDef ?? (_initFieldDef = InitializeFieldDefinition)));
}
internal FieldForInstantiatedType(FieldDesc fieldDef, InstantiatedType instantiatedType)
{
Debug.Assert(fieldDef.GetTypicalFieldDefinition() == fieldDef);
_fieldDef = fieldDef;
_instantiatedType = instantiatedType;
}
private MemberReference HandleFieldReference(Cts.FieldDesc field)
{
Debug.Assert(field.GetTypicalFieldDefinition() == field);
Debug.Assert(!_policy.GeneratesMetadata(field));
return((MemberReference)_fields.GetOrCreate(field, _initFieldRef ?? (_initFieldRef = InitializeFieldReference)));
}
protected internal override bool ComputeHasGCStaticBase(FieldDesc field)
{
Debug.Assert(field.IsStatic);
if (field is NativeLayoutFieldDesc)
{
return ((NativeLayoutFieldDesc)field).FieldStorage == Internal.NativeFormat.FieldStorage.GCStatic;
}
TypeDesc fieldType = field.FieldType;
if (fieldType.IsValueType)
{
FieldDesc typicalField = field.GetTypicalFieldDefinition();
if (field != typicalField)
{
if (typicalField.FieldType.IsSignatureVariable)
return true;
}
if (fieldType.IsEnum || fieldType.IsPrimitive)
return false;
return true;
}
else
return fieldType.IsGCPointer;
}
