public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) { if (_methods.Count == 0 || relocsOnly) { return(new ObjectData( data: Array.Empty <byte>(), relocs: Array.Empty <Relocation>(), alignment: 1, definedSymbols: new ISymbolDefinitionNode[] { this })); } GCRefMapBuilder builder = new GCRefMapBuilder(factory, relocsOnly); builder.Builder.RequireInitialAlignment(4); builder.Builder.AddSymbol(this); // First, emit the initial ref map offset and reserve the offset map entries int offsetCount = _methods.Count / GCREFMAP_LOOKUP_STRIDE; builder.Builder.EmitInt((offsetCount + 1) * sizeof(int)); ObjectDataBuilder.Reservation[] offsets = new ObjectDataBuilder.Reservation[offsetCount]; for (int offsetIndex = 0; offsetIndex < offsetCount; offsetIndex++) { offsets[offsetIndex] = builder.Builder.ReserveInt(); } // Next, generate the actual method GC ref maps and update the offset map int nextOffsetIndex = 0; int nextMethodIndex = GCREFMAP_LOOKUP_STRIDE - 1; for (int methodIndex = 0; methodIndex < _methods.Count; methodIndex++) { if (methodIndex >= nextMethodIndex) { builder.Builder.EmitInt(offsets[nextOffsetIndex], builder.Builder.CountBytes); nextOffsetIndex++; nextMethodIndex += GCREFMAP_LOOKUP_STRIDE; } MethodWithGCInfo methodNode = _methods[methodIndex]; if (methodNode == null || methodNode.IsEmpty) { // Flush an empty GC ref map block to prevent // the indexed records from falling out of sync with methods builder.Flush(); } else { builder.GetCallRefMap(methodNode.Method); } } Debug.Assert(nextOffsetIndex == offsets.Length); return(builder.Builder.ToObjectData()); }
public override int CompareToImpl(ISortableNode other, CompilerComparer comparer) { MethodWithGCInfo otherNode = (MethodWithGCInfo)other; int result = comparer.Compare(_method, otherNode._method); if (result != 0) { return(result); } return(SignatureContext.CompareTo(otherNode.SignatureContext, comparer)); }
public int GetIndex(MethodWithGCInfo method) { #if DEBUG Debug.Assert(_nodeFactory.MarkingComplete); Debug.Assert(method.Marked); #endif if (_methodNodes == null) { LayoutRuntimeFunctions(); } return(_insertedMethodNodes[method]); }
public PrecodeMethodImport( NodeFactory factory, ReadyToRunFixupKind fixupKind, MethodWithToken method, MethodWithGCInfo localMethod, bool isInstantiatingStub) : base( factory, factory.MethodSignature( fixupKind, method, isInstantiatingStub) ) { _localMethod = localMethod; _method = method; }
private ArraySignatureBuilder BuildSignatureForMethod(MethodWithGCInfo method, NodeFactory factory) { // In composite R2R format, always enforce owning type to let us share generic instantiations among modules EcmaMethod typicalMethod = (EcmaMethod)method.Method.GetTypicalMethodDefinition(); ModuleToken moduleToken = new ModuleToken(typicalMethod.Module, typicalMethod.Handle); ArraySignatureBuilder signatureBuilder = new ArraySignatureBuilder(); signatureBuilder.EmitMethodSignature( new MethodWithToken(method.Method, moduleToken, constrainedType: null, unboxing: false, context: null), enforceDefEncoding: true, enforceOwningType: _factory.CompilationModuleGroup.EnforceOwningType(moduleToken.Module), factory.SignatureContext, isInstantiatingStub: false); return(signatureBuilder); }
public DelayLoadMethodImport( NodeFactory factory, ReadyToRunFixupKind fixupKind, MethodWithToken method, MethodWithGCInfo localMethod, bool isInstantiatingStub) : base( factory, factory.MethodImports, ReadyToRunHelper.DelayLoad_MethodCall, factory.MethodSignature( fixupKind, method, isInstantiatingStub)) { _localMethod = localMethod; _method = method; }
public PrecodeMethodImport( ReadyToRunCodegenNodeFactory factory, ReadyToRunFixupKind fixupKind, MethodWithToken method, MethodWithGCInfo localMethod, bool isUnboxingStub, bool isInstantiatingStub, SignatureContext signatureContext) : base( factory, factory.MethodSignature( fixupKind, method, isUnboxingStub, isInstantiatingStub, signatureContext) ) { _localMethod = localMethod; }
public LocalMethodImport( ReadyToRunCodegenNodeFactory factory, ReadyToRunFixupKind fixupKind, MethodWithToken method, MethodWithGCInfo localMethod, bool isUnboxingStub, bool isInstantiatingStub, SignatureContext signatureContext) : base( factory, factory.MethodImports, ReadyToRunHelper.READYTORUN_HELPER_DelayLoad_MethodCall, factory.MethodSignature( fixupKind, method, isUnboxingStub, isInstantiatingStub, signatureContext)) { _signatureContext = signatureContext; _localMethod = localMethod; }
public LocalMethodImport( ReadyToRunCodegenNodeFactory factory, ReadyToRunFixupKind fixupKind, MethodWithGCInfo localMethod, bool isUnboxingStub, SignatureContext signatureContext) : base( factory, factory.MethodImports, ReadyToRunHelper.READYTORUN_HELPER_DelayLoad_MethodCall, factory.MethodSignature( fixupKind, localMethod.Method, constrainedType: null, methodToken: default(ModuleToken), signatureContext, isUnboxingStub, isInstantiatingStub: false)) { _signatureContext = signatureContext; _localMethod = localMethod; }
private byte[] CreateBoundsBlobForMethod(MethodWithGCInfo method) { if (method.DebugLocInfos == null || method.DebugLocInfos.Length == 0) { return(null); } NibbleWriter writer = new NibbleWriter(); writer.WriteUInt((uint)method.DebugLocInfos.Length); uint previousNativeOffset = 0; foreach (var locInfo in method.DebugLocInfos) { writer.WriteUInt(locInfo.nativeOffset - previousNativeOffset); writer.WriteUInt(locInfo.ilOffset + 3); // Count of items in Internal.JitInterface.MappingTypes to adjust the IL offset by writer.WriteUInt((uint)locInfo.source); previousNativeOffset = locInfo.nativeOffset; } return(writer.ToArray()); }
public EntryPoint(int methodIndex, MethodWithGCInfo method) { MethodIndex = methodIndex; Method = method; }
public ProfileDataNode(MethodWithGCInfo methodNode, TargetDetails targetDetails) { _methodNode = methodNode; _targetDetails = targetDetails; }
public MethodGCInfoNode(MethodWithGCInfo methodNode) { _methodNode = methodNode; }
public override int CompareToImpl(ISortableNode other, CompilerComparer comparer) { MethodWithGCInfo otherNode = (MethodWithGCInfo)other; return(comparer.Compare(_method, otherNode._method)); }
private byte[] CreateVarBlobForMethod(MethodWithGCInfo method) { if (method.DebugVarInfos == null || method.DebugVarInfos.Length == 0) { return(null); } NibbleWriter writer = new NibbleWriter(); writer.WriteUInt((uint)method.DebugVarInfos.Length); foreach (var nativeVarInfo in method.DebugVarInfos) { writer.WriteUInt(nativeVarInfo.startOffset); writer.WriteUInt(nativeVarInfo.endOffset - nativeVarInfo.startOffset); writer.WriteUInt((uint)(nativeVarInfo.varNumber - (int)ILNum.MAX_ILNUM)); VarLocType varLocType = nativeVarInfo.varLoc.LocationType; writer.WriteUInt((uint)varLocType); switch (varLocType) { case VarLocType.VLT_REG: case VarLocType.VLT_REG_FP: case VarLocType.VLT_REG_BYREF: writer.WriteUInt((uint)nativeVarInfo.varLoc.B); break; case VarLocType.VLT_STK: case VarLocType.VLT_STK_BYREF: writer.WriteUInt((uint)nativeVarInfo.varLoc.B); writer.WriteInt(nativeVarInfo.varLoc.C); break; case VarLocType.VLT_REG_REG: writer.WriteUInt((uint)nativeVarInfo.varLoc.B); writer.WriteUInt((uint)nativeVarInfo.varLoc.C); break; case VarLocType.VLT_REG_STK: writer.WriteUInt((uint)nativeVarInfo.varLoc.B); writer.WriteUInt((uint)nativeVarInfo.varLoc.C); writer.WriteInt(nativeVarInfo.varLoc.D); break; case VarLocType.VLT_STK_REG: writer.WriteInt(nativeVarInfo.varLoc.B); writer.WriteUInt((uint)nativeVarInfo.varLoc.C); writer.WriteUInt((uint)nativeVarInfo.varLoc.D); break; case VarLocType.VLT_STK2: writer.WriteUInt((uint)nativeVarInfo.varLoc.B); writer.WriteInt(nativeVarInfo.varLoc.C); break; case VarLocType.VLT_FPSTK: writer.WriteUInt((uint)nativeVarInfo.varLoc.B); break; case VarLocType.VLT_FIXED_VA: writer.WriteUInt((uint)nativeVarInfo.varLoc.B); break; default: throw new BadImageFormatException("Unexpected var loc type"); } } return(writer.ToArray()); }
private byte[] BuildSignatureForMethod(MethodWithGCInfo method, NodeFactory factory) { return(BuildSignatureForMethodDefinedInModule(method.Method, factory)); }