/// <summary>
/// Gets the size of the field.
/// </summary>
/// <param name="field">The field.</param>
/// <returns></returns>
int ITypeLayout.GetFieldSize(RuntimeField field)
{
int size = 0;
if (fieldSizes.TryGetValue(field, out size))
{
return(size);
}
else
{
ResolveType(field.DeclaringType);
}
// If the field is another struct, we have to dig down and compute its size too.
if (field.SignatureType.Type == CilElementType.ValueType)
{
size = ((ITypeLayout)this).GetTypeSize(field.DeclaringType);
}
else
{
size = GetMemorySize(field.SignatureType);
}
fieldSizes.Add(field, size);
return(size);
}
/// <summary>
/// Initializes a new instance of <see cref="MemberOperand"/>.
/// </summary>
/// <param name="field">The runtime field to reference.</param>
/// <exception cref="System.ArgumentNullException"><paramref name="field"/> is null.</exception>
public MemberOperand(RuntimeField field)
: base(field.SignatureType, null, IntPtr.Zero)
{
if (field == null)
throw new ArgumentNullException(@"field");
this.member = field;
}
/// <summary>
/// Initializes a new instance of the <see cref="CilGenericField"/> class.
/// </summary>
/// <param name="module">The module.</param>
/// <param name="genericField">The generic field.</param>
/// <param name="signature">The signature.</param>
/// <param name="declaringType">Type of the declaring.</param>
public CilGenericField(ITypeModule module, RuntimeField genericField, FieldSignature signature, CilGenericType declaringType)
: base(module, declaringType)
{
this.Signature = signature;
this.Attributes = genericField.Attributes;
//TODO
//this.SetAttributes(genericField.CustomAttributes);
base.Name = genericField.Name;
}
/// <summary>
/// Gets the size of the field.
/// </summary>
/// <param name="field">The field.</param>
/// <returns></returns>
int ITypeLayout.GetFieldOffset(RuntimeField field)
{
ResolveType(field.DeclaringType);
int size = 0;
fieldOffets.TryGetValue(field, out size);
return(size);
}
/// <summary>
/// Gets the size of the field.
/// </summary>
/// <param name="field">The field.</param>
/// <returns></returns>
int ITypeLayout.GetFieldSize(RuntimeField field)
{
int size = 0;
if (fieldSizes.TryGetValue(field, out size))
{
return size;
}
else
{
ResolveType(field.DeclaringType);
}
// If the field is another struct, we have to dig down and compute its size too.
if (field.SignatureType.Type == CilElementType.ValueType)
{
size = ((ITypeLayout)this).GetTypeSize(field.DeclaringType);
}
else
{
size = GetMemorySize(field.SignatureType);
}
fieldSizes.Add(field, size);
return size;
}
/// <summary>
/// Gets the size of the field.
/// </summary>
/// <param name="field">The field.</param>
/// <returns></returns>
int ITypeLayout.GetFieldOffset(RuntimeField field)
{
ResolveType(field.DeclaringType);
int size = 0;
fieldOffets.TryGetValue(field, out size);
return size;
}
/// <summary>
/// Creates a new SymbolOperand for the given runtime field.
/// </summary>
/// <param name="runtimeField">The field to create a symbol operand for.</param>
/// <returns>The created symbol operand.</returns>
public static SymbolOperand FromField(RuntimeField runtimeField)
{
return new SymbolOperand(runtimeField.SignatureType, runtimeField.ToString());
}
/* field.Address */
/// <summary>
/// Initializes a new instance of the <see cref="StaticFieldOperand"/> class.
/// </summary>
/// <param name="field">The field.</param>
public StaticFieldOperand(RuntimeField field, IntPtr offset)
: base(field.SignatureType, null, offset)
{
}
private void InitializeStaticValueFromRVA(Stream stream, int size, RuntimeField field)
{
using (Stream source = field.Module.MetadataModule.GetDataSection((long)field.RVA))
{
byte[] data = new byte[size];
source.Read(data, 0, size);
stream.Write(data, 0, size);
}
}
/// <summary>
/// Allocates memory for the static field and initializes it.
/// </summary>
/// <param name="field">The field.</param>
private void CreateStaticField(RuntimeField field)
{
Debug.Assert(field != null, @"No field given.");
// Determine the size of the type & alignment requirements
int size, alignment;
architecture.GetTypeRequirements(field.SignatureType, out size, out alignment);
size = (int)typeLayout.GetFieldSize(field);
// The linker section to move this field into
SectionKind section;
// Does this field have an RVA?
if (field.RVA != 0)
{
// FIXME: Move a static field into ROData, if it is read-only and can be initialized
// using static analysis
section = SectionKind.Data;
}
else
{
section = SectionKind.BSS;
}
this.AllocateSpace(field, section, size, alignment);
}
private void AllocateSpace(RuntimeField field, SectionKind section, int size, int alignment)
{
using (Stream stream = linker.Allocate(field.ToString(), section, size, alignment))
{
if (field.RVA != 0)
{
InitializeStaticValueFromRVA(stream, size, field);
}
else
{
WriteDummyBytes(stream, size);
}
}
}
/* field.Address */
/// <summary>
/// Initializes a new instance of the <see cref="ObjectFieldOperand"/> class.
/// </summary>
/// <param name="objectInstance">The operand, representing the object instance.</param>
/// <param name="field">The referenced field.</param>
public ObjectFieldOperand(Operand objectInstance, RuntimeField field, IntPtr offset)
: base(field.SignatureType, null, offset)
{
}