public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
{
ObjectDataSignatureBuilder builder = new ObjectDataSignatureBuilder();
builder.AddSymbol(this);
string[] supportedAndUnsupportedSplit = _instructionSetsSupport.Split(',');
string[] instructionSetsSupported = supportedAndUnsupportedSplit[0] == "" ? Array.Empty <string>() : supportedAndUnsupportedSplit[0].Split('+');
string[] instructionSetsExplicitlyUnsupported = supportedAndUnsupportedSplit[1] == "" ? Array.Empty <string>() : supportedAndUnsupportedSplit[1].Split('-');
// This type of fixup is not dependent on module
builder.EmitByte(checked ((byte)ReadyToRunFixupKind.Check_InstructionSetSupport));
builder.EmitUInt((uint)(instructionSetsSupported.Length + instructionSetsExplicitlyUnsupported.Length));
foreach (string instructionSetString in instructionSetsSupported)
{
uint valueToEmit = (((uint)InstructionSetFromString(instructionSetString)) << 1) | 1;
builder.EmitUInt(valueToEmit);
}
foreach (string instructionSetString in instructionSetsExplicitlyUnsupported)
{
uint valueToEmit = (((uint)InstructionSetFromString(instructionSetString)) << 1) | 0;
builder.EmitUInt(valueToEmit);
}
return(builder.ToObjectData());
}
public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
{
ObjectDataSignatureBuilder dataBuilder = new ObjectDataSignatureBuilder();
if (!relocsOnly)
{
dataBuilder.AddSymbol(this);
ModuleToken moduleToken = GetModuleToken(factory);
IEcmaModule targetModule = moduleToken.Module;
SignatureContext innerContext = dataBuilder.EmitFixup(factory, _fixupKind, targetModule, factory.SignatureContext);
var metadata = ReadyToRunStandaloneMethodMetadata.Compute(_method);
dataBuilder.EmitUInt(checked ((uint)metadata.ConstantData.Length));
dataBuilder.EmitBytes(metadata.ConstantData);
dataBuilder.EmitUInt(checked ((uint)metadata.TypeRefs.Length));
foreach (var typeRef in metadata.TypeRefs)
{
if (factory.SignatureContext.Resolver.GetModuleTokenForType((EcmaType)typeRef, allowDynamicallyCreatedReference: true, throwIfNotFound: false).Module == null)
{
// If there isn't a module token yet for this type, force it to exist
factory.ManifestMetadataTable._mutableModule.TryGetEntityHandle(typeRef);
}
dataBuilder.EmitTypeSignature(typeRef, innerContext);
}
MethodWithToken method = new MethodWithToken(_method, moduleToken, null, unboxing: false, context: null);
dataBuilder.EmitMethodSignature(method, enforceDefEncoding: false, enforceOwningType: false, innerContext, false);
}
return(dataBuilder.ToObjectData());
}
public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
{
ObjectDataSignatureBuilder dataBuilder = new ObjectDataSignatureBuilder();
if (!relocsOnly)
{
dataBuilder.AddSymbol(this);
EcmaModule targetModule = factory.SignatureContext.GetTargetModule(_fieldDesc);
SignatureContext innerContext = dataBuilder.EmitFixup(factory, _fixupKind, targetModule, factory.SignatureContext);
if (_fixupKind == ReadyToRunFixupKind.Verify_FieldOffset)
{
TypeDesc baseType = _fieldDesc.OwningType.BaseType;
if ((_fieldDesc.OwningType.BaseType != null) && !_fieldDesc.IsStatic && !_fieldDesc.OwningType.IsValueType)
{
dataBuilder.EmitUInt((uint)_fieldDesc.OwningType.FieldBaseOffset().AsInt);
}
else
{
dataBuilder.EmitUInt(0);
}
}
if ((_fixupKind == ReadyToRunFixupKind.Check_FieldOffset) ||
(_fixupKind == ReadyToRunFixupKind.Verify_FieldOffset))
{
dataBuilder.EmitUInt((uint)_fieldDesc.Offset.AsInt);
}
dataBuilder.EmitFieldSignature(_fieldDesc, innerContext);
}
return(dataBuilder.ToObjectData());
}
public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
{
ObjectDataSignatureBuilder builder = new ObjectDataSignatureBuilder();
builder.AddSymbol(this);
builder.EmitUInt((uint)ReadyToRunFixupKind.READYTORUN_FIXUP_Helper);
builder.EmitUInt((uint)_helperID);
return(builder.ToObjectData());
}
public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
{
ObjectDataSignatureBuilder dataBuilder = new ObjectDataSignatureBuilder();
if (!relocsOnly)
{
dataBuilder.AddSymbol(this);
IEcmaModule targetModule = _fieldWithToken.Token.Module;
SignatureContext innerContext = dataBuilder.EmitFixup(factory, _fixupKind, targetModule, factory.SignatureContext);
uint baseOffset = 0;
uint fieldOffset = (uint)_fieldWithToken.Field.Offset.AsInt;
if (_fixupKind == ReadyToRunFixupKind.Verify_FieldOffset)
{
TypeDesc baseType = _fieldWithToken.Field.OwningType.BaseType;
if ((_fieldWithToken.Field.OwningType.BaseType != null) &&
!_fieldWithToken.Field.IsStatic &&
!_fieldWithToken.Field.OwningType.IsValueType)
{
MetadataType owningType = (MetadataType)_fieldWithToken.Field.OwningType;
baseOffset = (uint)owningType.FieldBaseOffset().AsInt;
if (factory.CompilationModuleGroup.NeedsAlignmentBetweenBaseTypeAndDerived((MetadataType)baseType, owningType))
{
fieldOffset -= baseOffset;
baseOffset = 0;
}
}
dataBuilder.EmitUInt(baseOffset);
}
if ((_fixupKind == ReadyToRunFixupKind.Check_FieldOffset) ||
(_fixupKind == ReadyToRunFixupKind.Verify_FieldOffset))
{
dataBuilder.EmitUInt(fieldOffset);
}
dataBuilder.EmitFieldSignature(_fieldWithToken, innerContext);
}
return(dataBuilder.ToObjectData());
}
public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
{
ReadyToRunCodegenNodeFactory r2rFactory = (ReadyToRunCodegenNodeFactory)factory;
ObjectDataSignatureBuilder dataBuilder = new ObjectDataSignatureBuilder();
dataBuilder.AddSymbol(this);
dataBuilder.EmitFixup(r2rFactory, ReadyToRunFixupKind.READYTORUN_FIXUP_StringHandle, _token.Module, _signatureContext);
dataBuilder.EmitUInt(_token.TokenRid);
return(dataBuilder.ToObjectData());
}
public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
{
ReadyToRunCodegenNodeFactory r2rFactory = (ReadyToRunCodegenNodeFactory)factory;
ObjectDataSignatureBuilder dataBuilder = new ObjectDataSignatureBuilder();
dataBuilder.AddSymbol(this);
// TODO: module override for external module strings
dataBuilder.EmitByte((byte)ReadyToRunFixupKind.READYTORUN_FIXUP_StringHandle);
dataBuilder.EmitUInt(_token.TokenRid);
return(dataBuilder.ToObjectData());
}
public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
{
ObjectDataSignatureBuilder dataBuilder = new ObjectDataSignatureBuilder();
if (!relocsOnly)
{
dataBuilder.AddSymbol(this);
dataBuilder.EmitFixup(factory, ReadyToRunFixupKind.StringHandle, _token.Module, _signatureContext);
dataBuilder.EmitUInt(_token.TokenRid);
}
return(dataBuilder.ToObjectData());
}
public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
{
if (relocsOnly)
{
// Method fixup signature doesn't contain any direct relocs
return(new ObjectData(data: Array.Empty <byte>(), relocs: null, alignment: 0, definedSymbols: null));
}
ReadyToRunCodegenNodeFactory r2rFactory = (ReadyToRunCodegenNodeFactory)factory;
ObjectDataSignatureBuilder dataBuilder = new ObjectDataSignatureBuilder();
dataBuilder.AddSymbol(this);
dataBuilder.EmitUInt((uint)_fixupKind);
dataBuilder.EmitMethodSignature(_methodDesc, _constrainedType, _methodToken, enforceDefEncoding: false,
_signatureContext, _isUnboxingStub, _isInstantiatingStub);
return(dataBuilder.ToObjectData());
}
public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
{
ObjectDataSignatureBuilder dataBuilder = new ObjectDataSignatureBuilder();
if (!relocsOnly)
{
dataBuilder.AddSymbol(this);
SignatureContext innerContext = dataBuilder.EmitFixup(factory, _fixupKind, _declMethod.Token.Module, factory.SignatureContext);
dataBuilder.EmitUInt((uint)(_implMethod != null ? ReadyToRunVirtualFunctionOverrideFlags.VirtualFunctionOverridden : ReadyToRunVirtualFunctionOverrideFlags.None));
dataBuilder.EmitMethodSignature(_declMethod, enforceDefEncoding: false, enforceOwningType: false, innerContext, isInstantiatingStub: false);
dataBuilder.EmitTypeSignature(_implType, innerContext);
if (_implMethod != null)
{
dataBuilder.EmitMethodSignature(_implMethod, enforceDefEncoding: false, enforceOwningType: false, innerContext, isInstantiatingStub: false);
}
}
return(dataBuilder.ToObjectData());
}
private static void EncodeTypeLayout(ObjectDataSignatureBuilder dataBuilder, TypeDesc type)
{
Debug.Assert(type.IsValueType);
MetadataType defType = (MetadataType)type;
int pointerSize = type.Context.Target.PointerSize;
int size = defType.InstanceFieldSize.AsInt;
int alignment = GetClassAlignmentRequirement(defType);
ReadyToRunTypeLayoutFlags flags = ReadyToRunTypeLayoutFlags.READYTORUN_LAYOUT_Alignment | ReadyToRunTypeLayoutFlags.READYTORUN_LAYOUT_GCLayout;
if (alignment == pointerSize)
{
flags |= ReadyToRunTypeLayoutFlags.READYTORUN_LAYOUT_Alignment_Native;
}
if (!defType.ContainsGCPointers)
{
flags |= ReadyToRunTypeLayoutFlags.READYTORUN_LAYOUT_GCLayout_Empty;
}
if (defType.IsHomogeneousAggregate)
{
flags |= ReadyToRunTypeLayoutFlags.READYTORUN_LAYOUT_HFA;
}
dataBuilder.EmitUInt((uint)flags);
dataBuilder.EmitUInt((uint)size);
if (defType.IsHomogeneousAggregate)
{
CorElementType elementType = (defType.ValueTypeShapeCharacteristics & ValueTypeShapeCharacteristics.AggregateMask) switch
{
ValueTypeShapeCharacteristics.Float32Aggregate => CorElementType.ELEMENT_TYPE_R4,
ValueTypeShapeCharacteristics.Float64Aggregate => CorElementType.ELEMENT_TYPE_R8,
ValueTypeShapeCharacteristics.Vector64Aggregate => CorElementType.ELEMENT_TYPE_R8,
// See MethodTable::GetHFAType
ValueTypeShapeCharacteristics.Vector128Aggregate => CorElementType.ELEMENT_TYPE_VALUETYPE,
_ => CorElementType.Invalid
};
dataBuilder.EmitUInt((uint)elementType);
}
if (alignment != pointerSize)
{
dataBuilder.EmitUInt((uint)alignment);
}
if (defType.ContainsGCPointers)
{
// Encode the GC pointer map
GCPointerMap gcMap = GCPointerMap.FromInstanceLayout(defType);
byte[] encodedGCRefMap = new byte[(size / pointerSize + 7) / 8];
int bitIndex = 0;
foreach (bool bit in gcMap)
{
if (bit)
{
encodedGCRefMap[bitIndex / 8] |= (byte)(1 << (bitIndex & 7));
}
++bitIndex;
}
dataBuilder.EmitBytes(encodedGCRefMap);
}
}
private static void EncodeTypeLayout(ObjectDataSignatureBuilder dataBuilder, TypeDesc type)
{
Debug.Assert(type.IsValueType);
MetadataType defType = (MetadataType)type;
int pointerSize = type.Context.Target.PointerSize;
int size = defType.InstanceFieldSize.AsInt;
int alignment = GetClassAlignmentRequirement(defType);
ReadyToRunTypeLayoutFlags flags = ReadyToRunTypeLayoutFlags.READYTORUN_LAYOUT_Alignment | ReadyToRunTypeLayoutFlags.READYTORUN_LAYOUT_GCLayout;
if (alignment == pointerSize)
{
flags |= ReadyToRunTypeLayoutFlags.READYTORUN_LAYOUT_Alignment_Native;
}
if (!defType.ContainsGCPointers)
{
flags |= ReadyToRunTypeLayoutFlags.READYTORUN_LAYOUT_GCLayout_Empty;
}
if (defType.IsHfa)
{
flags |= ReadyToRunTypeLayoutFlags.READYTORUN_LAYOUT_HFA;
}
dataBuilder.EmitUInt((uint)flags);
dataBuilder.EmitUInt((uint)size);
if (defType.IsHfa)
{
switch (defType.HfaElementType.Category)
{
case TypeFlags.Single:
dataBuilder.EmitUInt((uint)CorElementType.ELEMENT_TYPE_R4);
break;
case TypeFlags.Double:
dataBuilder.EmitUInt((uint)CorElementType.ELEMENT_TYPE_R8);
break;
}
}
if (alignment != pointerSize)
{
dataBuilder.EmitUInt((uint)alignment);
}
if (defType.ContainsGCPointers)
{
// Encode the GC pointer map
GCPointerMap gcMap = GCPointerMap.FromInstanceLayout(defType);
byte[] encodedGCRefMap = new byte[(size / pointerSize + 7) / 8];
int bitIndex = 0;
foreach (bool bit in gcMap)
{
if (bit)
{
encodedGCRefMap[bitIndex / 8] |= (byte)(1 << (bitIndex & 7));
}
++bitIndex;
}
dataBuilder.EmitBytes(encodedGCRefMap);
}
}