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());
}
private void EmitModuleOverride(IEcmaModule module, SignatureContext context)
{
if (module != context.LocalContext)
{
EmitElementType(CorElementType.ELEMENT_TYPE_MODULE_ZAPSIG);
uint moduleIndex = (uint)context.Resolver.GetModuleIndex(module);
EmitUInt(moduleIndex);
}
}
public int ModuleToIndex(IEcmaModule module)
{
if (!_nodeFactory.MarkingComplete)
{
// If we call this function before sorting is complete, we might have a determinism bug caused by
// compiling two functions in an arbitrary order and hence getting different module IDs.
throw new InvalidOperationException("Cannot get ModuleToIndex mapping until marking is complete.");
}
return(ModuleToIndexInternal(module));
}
public int CompareTo(IEcmaModule other)
{
if (this == other)
{
return(0);
}
if (other is EcmaModule emoduleOther)
{
return(CompareTo(emoduleOther));
}
return(ModuleTypeSort.CompareTo(other.ModuleTypeSort));
}
public int CompareTo(IEcmaModule other)
{
if (other == this)
{
return(0);
}
if (other is MutableModule mutableModule)
{
return(CompareTo(mutableModule));
}
return(ModuleTypeSort.CompareTo(other.ModuleTypeSort));
}
private void EmitInstantiatedTypeSignature(InstantiatedType type, SignatureContext context)
{
IEcmaModule targetModule = context.GetTargetModule(type);
EmitModuleOverride(targetModule, context);
EmitElementType(CorElementType.ELEMENT_TYPE_GENERICINST);
EmitTypeSignature(type.GetTypeDefinition(), context.InnerContext(targetModule));
SignatureContext outerContext = context.OuterContext;
EmitUInt((uint)type.Instantiation.Length);
for (int paramIndex = 0; paramIndex < type.Instantiation.Length; paramIndex++)
{
EmitTypeSignature(type.Instantiation[paramIndex], outerContext);
}
}
public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
{
ObjectDataSignatureBuilder dataBuilder = new ObjectDataSignatureBuilder();
if (!relocsOnly)
{
dataBuilder.AddSymbol(this);
IEcmaModule targetModule = factory.SignatureContext.GetTargetModule(_arrayType);
SignatureContext innerContext = dataBuilder.EmitFixup(factory, ReadyToRunFixupKind.NewArray, targetModule, factory.SignatureContext);
dataBuilder.EmitTypeSignature(_arrayType, innerContext);
}
return(dataBuilder.ToObjectData());
}
private int ModuleToIndexInternal(IEcmaModule module)
{
Debug.Assert(module != null);
EcmaModule emodule = module as EcmaModule;
if (emodule == null)
{
Debug.Assert(module == _mutableModule);
return(_assemblyRefCount + 1);
}
if (!_nodeFactory.CompilationModuleGroup.IsCompositeBuildMode && (_nodeFactory.CompilationModuleGroup.CompilationModuleSet.Single() == module))
{
// Must be a reference to the only module being compiled
return(0);
}
AssemblyName assemblyName = emodule.Assembly.GetName();
int assemblyRefIndex;
if (!_assemblyRefToModuleIdMap.TryGetValue(assemblyName.Name, out assemblyRefIndex))
{
assemblyRefIndex = _nextModuleId++;
_assemblyRefToModuleIdMap.Add(assemblyName.Name, assemblyRefIndex);
}
if (assemblyRefIndex > _assemblyRefCount && !_moduleIdToAssemblyNameMap.ContainsKey(assemblyRefIndex))
{
if (_emissionCompleted)
{
throw new InvalidOperationException("Adding a new assembly after signatures have been materialized.");
}
_moduleIdToAssemblyNameMap.Add(assemblyRefIndex, assemblyName);
if (_nodeFactory.CompilationModuleGroup.VersionsWithModule(emodule))
{
_manifestAssemblyMvids.Add(module.MetadataReader.GetGuid(module.MetadataReader.GetModuleDefinition().Mvid));
}
else
{
Debug.Assert(_nodeFactory.CompilationModuleGroup.CrossModuleInlineableModule(emodule));
_manifestAssemblyMvids.Add(default(Guid));
}
}
return(assemblyRefIndex);
}
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)
{
ObjectDataSignatureBuilder dataBuilder = new ObjectDataSignatureBuilder();
if (!relocsOnly)
{
dataBuilder.AddSymbol(this);
IEcmaModule targetModule = factory.SignatureContext.GetTargetModule(_typeDesc);
SignatureContext innerContext = dataBuilder.EmitFixup(factory, _fixupKind, targetModule, factory.SignatureContext);
dataBuilder.EmitTypeSignature(_typeDesc, innerContext);
if ((_fixupKind == ReadyToRunFixupKind.Check_TypeLayout) ||
(_fixupKind == ReadyToRunFixupKind.Verify_TypeLayout))
{
EncodeTypeLayout(dataBuilder, _typeDesc);
}
}
return(dataBuilder.ToObjectData());
}
public ModuleToken(IEcmaModule module, mdToken token)
{
Module = module;
Token = token;
}
public TokenResolverProvider(ModuleTokenResolver resolver, IEcmaModule contextModule)
{
_resolver = resolver;
_contextModule = contextModule;
}
public int GetModuleIndex(IEcmaModule module)
{
return(_moduleIndexLookup(module));
}
public ModuleToken(IEcmaModule module, Handle handle)
{
Module = module;
Token = (mdToken)MetadataTokens.GetToken(handle);
}
public SignatureContext EmitFixup(NodeFactory factory, ReadyToRunFixupKind fixupKind, IEcmaModule targetModule, SignatureContext outerContext)
{
if (targetModule == outerContext.LocalContext)
{
EmitByte((byte)fixupKind);
return(outerContext);
}
else
{
EmitByte((byte)(fixupKind | ReadyToRunFixupKind.ModuleOverride));
EmitUInt((uint)factory.ManifestMetadataTable.ModuleToIndex(targetModule));
return(new SignatureContext(targetModule, outerContext.Resolver));
}
}
public SignatureContext(IEcmaModule context, ModuleTokenResolver resolver)
{
GlobalContext = context;
LocalContext = context;
Resolver = resolver;
}
private SignatureContext(IEcmaModule globalContext, IEcmaModule localContext, ModuleTokenResolver resolver)
{
GlobalContext = globalContext;
LocalContext = localContext;
Resolver = resolver;
}
public SignatureContext InnerContext(IEcmaModule innerContext)
{
return(new SignatureContext(GlobalContext, innerContext, Resolver));
}
public ModuleToken(IEcmaModule module, EntityHandle entityHandle)
{
Module = module;
Token = (mdToken)MetadataTokens.GetToken(entityHandle);
}
/// <summary>
/// When set to true, unconditionally add module overrides to all signatures. This is needed in composite
/// build mode so that import cells and instance entry point table are caller module-agnostic.
/// </summary>
public bool EnforceOwningType(IEcmaModule module)
{
Debug.Assert(VersionsWithModule((ModuleDesc)module) || module is MutableModule);
return(IsCompositeBuildMode || module != CompilationModuleSet.Single());
}
