diff --git a/src/coreclr/jit/codegenwasm.cpp b/src/coreclr/jit/codegenwasm.cpp index 1483fe3882680c..c36fcb5290c4d9 100644 --- a/src/coreclr/jit/codegenwasm.cpp +++ b/src/coreclr/jit/codegenwasm.cpp @@ -3298,16 +3298,22 @@ void CodeGen::genCallInstruction(GenTreeCall* call) // Generate a direct call to a non-virtual user defined or helper method assert(call->IsHelperCall() || (call->gtCallType == CT_USER_FUNC)); - assert(call->gtEntryPoint.addr == NULL); - if (call->IsHelperCall()) { assert(!call->IsFastTailCall()); - CorInfoHelpFunc helperNum = m_compiler->eeGetHelperNum(params.methHnd); - noway_assert(helperNum != CORINFO_HELP_UNDEF); - CORINFO_CONST_LOOKUP helperLookup = m_compiler->compGetHelperFtn(helperNum); - assert(helperLookup.accessType == IAT_VALUE); - params.addr = helperLookup.addr; + + if (call->gtDirectCallAddress != nullptr) + { + params.addr = call->gtDirectCallAddress; + } + else + { + CorInfoHelpFunc helperNum = m_compiler->eeGetHelperNum(params.methHnd); + noway_assert(helperNum != CORINFO_HELP_UNDEF); + CORINFO_CONST_LOOKUP helperLookup = m_compiler->compGetHelperFtn(helperNum); + assert(helperLookup.accessType == IAT_VALUE); + params.addr = helperLookup.addr; + } } else { @@ -3350,9 +3356,8 @@ void CodeGen::genEmitHelperCall(unsigned helper, int argSize, emitAttr retSize, } else { - params.addr = nullptr; assert(helperFunction.accessType == IAT_PVALUE); - + params.addr = nullptr; params.callType = EC_INDIR_R; } @@ -3363,6 +3368,7 @@ void CodeGen::genEmitHelperCall(unsigned helper, int argSize, emitAttr retSize, CorInfoWasmType* types = nullptr; size_t typeCount = 0; bool helperIsManaged = false; + bool helperUsesPep = false; const bool MANAGED = true, UNMANAGED = false; #ifdef TARGET_64BIT @@ -3378,6 +3384,9 @@ void CodeGen::genEmitHelperCall(unsigned helper, int argSize, emitAttr retSize, types = helper_id##_types; \ typeCount = ArrLen(helper_id##_types); \ helperIsManaged = is_managed; \ + helperUsesPep = helperIsManaged && m_compiler->opts.jitFlags->IsSet(JitFlags::JIT_FLAG_PORTABLE_ENTRY_POINTS); \ + if (helperIsManaged /* `types` includes PEP */ && !helperUsesPep) \ + typeCount--; \ break; \ } @@ -3420,7 +3429,7 @@ void CodeGen::genEmitHelperCall(unsigned helper, int argSize, emitAttr retSize, params.wasmSignature = m_compiler->info.compCompHnd->getWasmTypeSymbol(types, typeCount); - if (helperIsManaged) + if (helperUsesPep) { // Push PEP onto the stack because we are calling a managed helper that expects it as the last parameter. // The helper function address is the address of an indirection cell, so we load from the cell to get the PEP diff --git a/src/coreclr/jit/emitwasm.cpp b/src/coreclr/jit/emitwasm.cpp index 3b6c8244023a5b..e8eb2e047730a7 100644 --- a/src/coreclr/jit/emitwasm.cpp +++ b/src/coreclr/jit/emitwasm.cpp @@ -300,7 +300,7 @@ void emitter::emitIns_Call(const EmitCallParams& params) { case EC_FUNC_TOKEN: ins = params.isJump ? INS_return_call : INS_call; - id = emitNewInstrSC(EA_HANDLE_CNS_RELOC, 0 /* FIXME-WASM: function index reloc */); + id = emitNewInstrSC(EA_HANDLE_CNS_RELOC, (cnsval_ssize_t)params.addr); id->idIns(ins); id->idInsFmt(IF_FUNCIDX); break; diff --git a/src/coreclr/jit/lower.cpp b/src/coreclr/jit/lower.cpp index d425a72e33f760..9d05d2a6ba9132 100644 --- a/src/coreclr/jit/lower.cpp +++ b/src/coreclr/jit/lower.cpp @@ -7380,21 +7380,27 @@ GenTree* Lowering::LowerVirtualVtableCall(GenTreeCall* call) { noway_assert(call->gtCallType == CT_USER_FUNC); - GenTree* thisArgNode; + CallArg* thisArg; if (call->IsTailCallViaJitHelper()) { assert(call->gtArgs.CountArgs() > 0); - thisArgNode = call->gtArgs.GetArgByIndex(0)->GetNode(); + thisArg = call->gtArgs.GetArgByIndex(0); } else { assert(call->gtArgs.HasThisPointer()); - thisArgNode = call->gtArgs.GetThisArg()->GetNode(); + thisArg = call->gtArgs.GetThisArg(); } + GenTree* thisArgNode = thisArg->GetNode(); // get a reference to the thisPtr being passed +#if HAS_FIXED_REGISTER_SET assert(thisArgNode->OperIs(GT_PUTARG_REG)); GenTree* thisPtr = thisArgNode->AsUnOp()->gtGetOp1(); +#else + // On platforms without fixed registers (e.g., WASM), PUTARG nodes are not inserted. + GenTree* thisPtr = thisArgNode; +#endif // If what we are passing as the thisptr is not already a local, make a new local to place it in // because we will be creating expressions based on it. @@ -7411,7 +7417,11 @@ GenTree* Lowering::LowerVirtualVtableCall(GenTreeCall* call) vtableCallTemp = m_compiler->lvaGrabTemp(true DEBUGARG("virtual vtable call")); } +#if HAS_FIXED_REGISTER_SET LIR::Use thisPtrUse(BlockRange(), &thisArgNode->AsUnOp()->gtOp1, thisArgNode); +#else + LIR::Use thisPtrUse(BlockRange(), &thisArg->NodeRef(), call); +#endif ReplaceWithLclVar(thisPtrUse, vtableCallTemp); lclNum = vtableCallTemp; diff --git a/src/coreclr/jit/lowerwasm.cpp b/src/coreclr/jit/lowerwasm.cpp index ab06ed972328bc..17a63814b27d04 100644 --- a/src/coreclr/jit/lowerwasm.cpp +++ b/src/coreclr/jit/lowerwasm.cpp @@ -35,11 +35,11 @@ void Lowering::SetMultiplyUsed(GenTree* node DEBUGARG(const char* reason)) // IsCallTargetInRange: Can a call target address be encoded in-place? // // Return Value: -// Currently always false for Wasm, all managed calls are indirect through the PEP. +// False when PEP is enabled, true when it is not enabled. // bool Lowering::IsCallTargetInRange(void* addr) { - return false; + return !m_compiler->opts.jitFlags->IsSet(JitFlags::JIT_FLAG_PORTABLE_ENTRY_POINTS); } //--------------------------------------------------------------------------------------------- diff --git a/src/coreclr/tools/Common/Compiler/ObjectWriter/WasmInstructions.cs b/src/coreclr/tools/Common/Compiler/ObjectWriter/WasmInstructions.cs index afc549c7171399..d8d03bb2e01aa8 100644 --- a/src/coreclr/tools/Common/Compiler/ObjectWriter/WasmInstructions.cs +++ b/src/coreclr/tools/Common/Compiler/ObjectWriter/WasmInstructions.cs @@ -204,7 +204,7 @@ public static bool IsVariableLengthInstruction(this WasmExprKind kind) // Represents a group of Wasm instructions (expressions) which // form a complete expression ending with the 'end' opcode. - public class WasmInstructionGroup : IWasmEncodable + internal sealed class WasmInstructionGroup : IWasmEncodable { private readonly WasmExpr[] _wasmExprs; public WasmInstructionGroup(WasmExpr[] wasmExprs) @@ -472,8 +472,8 @@ public override int Encode(Span buffer) internal sealed class WasmIndirectCallInstruction : WasmExpr { - private ISymbolNode _type; - private uint _tableIndex; + private readonly ISymbolNode _type; + private readonly uint _tableIndex; public WasmIndirectCallInstruction(WasmExprKind kind, ISymbolNode type, uint tableIndex) : base(kind) { @@ -752,17 +752,17 @@ internal enum WasmAbsHeapType : byte internal sealed class WasmRefNullExpr : WasmExpr { - private WasmAbsHeapType absheaptype; + private readonly WasmAbsHeapType _absoluteHeapType; public WasmRefNullExpr(WasmAbsHeapType heapType) : base(WasmExprKind.RefNull) { - absheaptype = heapType; + _absoluteHeapType = heapType; } public override int Encode(Span buffer) { int pos = base.Encode(buffer); - buffer[pos++] = (byte)absheaptype; + buffer[pos++] = (byte)_absoluteHeapType; return pos; } public override int EncodeSize() @@ -782,15 +782,17 @@ internal enum WasmBlockType : byte } internal sealed class WasmBlockStartExpr : WasmExpr { - private WasmBlockType BlockType; + private readonly WasmBlockType _blockType; + public WasmBlockStartExpr(WasmExprKind kind, WasmBlockType blockType) : base(kind) { - BlockType = blockType; + _blockType = blockType; } + public override int Encode(Span buffer) { int pos = base.Encode(buffer); - buffer[pos++] = (byte)BlockType; + buffer[pos++] = (byte)_blockType; return pos; } public override int EncodeSize() diff --git a/src/coreclr/tools/Common/Compiler/ObjectWriter/WasmNative.cs b/src/coreclr/tools/Common/Compiler/ObjectWriter/WasmNative.cs index 9bc77de3a9f201..401d1b74d97646 100644 --- a/src/coreclr/tools/Common/Compiler/ObjectWriter/WasmNative.cs +++ b/src/coreclr/tools/Common/Compiler/ObjectWriter/WasmNative.cs @@ -222,7 +222,7 @@ public WasmImport(string module, string name, WasmImportType import, int? index public int EncodeRelocations(Span buffer) => Import.EncodeRelocations(buffer); } - public class WasmGlobal : IWasmEncodable + internal sealed class WasmGlobal : IWasmEncodable { public readonly int Index; public readonly string Name; @@ -230,7 +230,7 @@ public class WasmGlobal : IWasmEncodable private readonly WasmMutabilityType _mutability; private readonly WasmInstructionGroup _initExpr; - public WasmGlobal(int index, string name, WasmValueType valueType, WasmMutabilityType mutability, WasmInstructionGroup initExpr) + internal WasmGlobal(int index, string name, WasmValueType valueType, WasmMutabilityType mutability, WasmInstructionGroup initExpr) { Index = index; Name = name; diff --git a/src/coreclr/tools/Common/Compiler/ObjectWriter/WasmObjectWriter.cs b/src/coreclr/tools/Common/Compiler/ObjectWriter/WasmObjectWriter.cs index e4b080690cd342..af2fcf8296d2e6 100644 --- a/src/coreclr/tools/Common/Compiler/ObjectWriter/WasmObjectWriter.cs +++ b/src/coreclr/tools/Common/Compiler/ObjectWriter/WasmObjectWriter.cs @@ -17,7 +17,7 @@ namespace ILCompiler.ObjectWriter { /// - /// Base class for WebAssembly object file format writers. + /// Base class for WebAssembly object writers. /// internal abstract partial class WasmObjectWriter : ObjectWriter { @@ -382,9 +382,12 @@ private protected void FinalizeSectionEntryCounts() _sections.GetSection(ObjectNodeSection.WasmCodeSection.Name) .SetEntryCount(MethodCount); - Debug.Assert(_sections.GetSection(WasmObjectNodeSection.FunctionSection.Name).EntryCount == MethodCount); - Debug.Assert(_sections.GetSection(WasmObjectNodeSection.ImportSection.Name).EntryCount == _wasmSymbolManager.GetImportCount()); - Debug.Assert(_sections.GetSection(WasmObjectNodeSection.GlobalSection.Name).EntryCount == _wasmSymbolManager.GetDefinitionCount(WasmIndexSpace.Global)); + Debug.Assert(!_sections.Contains(WasmObjectNodeSection.FunctionSection.Name) + || _sections.GetSection(WasmObjectNodeSection.FunctionSection.Name).EntryCount == MethodCount); + Debug.Assert(!_sections.Contains(WasmObjectNodeSection.ImportSection.Name) + || _sections.GetSection(WasmObjectNodeSection.ImportSection.Name).EntryCount == _wasmSymbolManager.GetImportCount()); + Debug.Assert(!_sections.Contains(WasmObjectNodeSection.GlobalSection.Name) + || _sections.GetSection(WasmObjectNodeSection.GlobalSection.Name).EntryCount == _wasmSymbolManager.GetDefinitionCount(WasmIndexSpace.Global)); } } diff --git a/src/coreclr/tools/Common/Compiler/ObjectWriter/WasmRelocatableObjectWriter.cs b/src/coreclr/tools/Common/Compiler/ObjectWriter/WasmRelocatableObjectWriter.cs index 864b3254183ee2..276c927aab2b3f 100644 --- a/src/coreclr/tools/Common/Compiler/ObjectWriter/WasmRelocatableObjectWriter.cs +++ b/src/coreclr/tools/Common/Compiler/ObjectWriter/WasmRelocatableObjectWriter.cs @@ -112,6 +112,7 @@ private protected override void EmitRelocations(int sectionIndex, List relocs, long sectionStart = 0) { + // TODO: We also need to emit relocations in the reloc section for the linker to resolve. byte[] relocScratchBuffer = new byte[Relocation.MaxSize]; foreach (SymbolicRelocation reloc in relocs) @@ -158,12 +159,25 @@ private unsafe void ResolveRelocations(int sectionIndex, MemoryStream sectionStr Relocation.WriteValue(reloc.Type, pData, symbol.Index + addend); break; } + case RelocType.IMAGE_REL_BASED_HIGHLOW: + { + if (_sections[definedSymbol.SectionIndex] is WasmDataSegmentEmitter segment) + { + int targetOffsetFromMemoryBase = segment.GetMemoryAddressOfOffset((int)(definedSymbol.Value + addend)); + Relocation.WriteValue(reloc.Type, pData, targetOffsetFromMemoryBase); + } + else + { + throw new NotImplementedException(); + } + break; + } default: // TODO-WASM: add other cases as needed; // ignoring other reloc types for now throw new NotSupportedException($"Relocation type {reloc.Type} for symbol '{reloc.SymbolName}' at " - + $"offset 0x{reloc.Offset:X} in section {sectionIndex} not yet implemented"); + + $"offset 0x{reloc.Offset:X} in section {_sections[sectionIndex].SectionName} not yet implemented"); } @@ -186,6 +200,9 @@ void WriteRelocFromDataSpan(SymbolicRelocation reloc, byte* pData, long sectionS } } + // TODO: This is a temporary workaround for the fact that we don't yet emit a COMDAT section (or any reloc / linking sections) + private protected override bool UsesSubsectionsViaSymbols => true; + private protected override SectionDataEmitter CreateDataSection( ObjectNodeSection section, int sectionIndex, @@ -245,6 +262,14 @@ private protected override void WriteImports() private protected override void WriteExports() { + // TODO-WASM: Handle exports better (e.g., only export public methods, etc.) + IEnumerable functionSymbols = _wasmSymbolManager.GetDefinitions( + WasmIndexSpace.Function, + Comparer.Create(static (x, y) => x.Name.CompareTo(y.Name))); + foreach (WasmSymbol symbol in functionSymbols) + { + WriteFunctionExport(symbol.Name.ToString(), symbol.Index); + } } private protected override void WriteElements() diff --git a/src/coreclr/tools/Common/Compiler/ObjectWriter/WasmSymbolManager.cs b/src/coreclr/tools/Common/Compiler/ObjectWriter/WasmSymbolManager.cs index 1fe51a1d5eb0f7..dbb2b52897fe1b 100644 --- a/src/coreclr/tools/Common/Compiler/ObjectWriter/WasmSymbolManager.cs +++ b/src/coreclr/tools/Common/Compiler/ObjectWriter/WasmSymbolManager.cs @@ -56,6 +56,7 @@ public T this[WasmIndexSpace indexSpace] } private readonly Dictionary _entries = new(); + private readonly Dictionary _aliases = new(); private IndexSpaceArray _importCounts = new IndexSpaceArray(); private IndexSpaceArray _definitionCounts = new IndexSpaceArray(); private IndexSpaceArray _importsFrozen = new IndexSpaceArray(); @@ -76,14 +77,23 @@ public void AddDefinition(Utf8String name, WasmIndexSpace indexSpace) _definitionCounts[indexSpace]++; } + public void AddAlias(Utf8String alias, Utf8String target) + { + Debug.Assert(!_entries.ContainsKey(alias), "Alias symbol name must not already exist."); + Debug.Assert(_entries.ContainsKey(target), "Target symbol name must exist before adding an alias."); + Entry entry = _entries[target]; + _aliases.Add(alias, entry with { Name = alias }); + } + public WasmSymbol GetSymbol(Utf8String name) { - return ResolveAndFreeze(_entries[name]); + return ResolveAndFreeze(GetEntry(name)); } public bool TryGetSymbol(Utf8String name, out WasmSymbol symbol) { - if (!_entries.TryGetValue(name, out Entry entry)) + if (!_entries.TryGetValue(name, out Entry entry) && + !_aliases.TryGetValue(name, out entry)) { symbol = default; return false; @@ -93,6 +103,9 @@ public bool TryGetSymbol(Utf8String name, out WasmSymbol symbol) return true; } + private Entry GetEntry(Utf8String name) => + _entries.TryGetValue(name, out Entry entry) ? entry : _aliases[name]; + public int GetImportCount() => _importCounts.Values.Sum(); public int GetDefinitionCount(WasmIndexSpace indexSpace) => diff --git a/src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs b/src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs index 6463dc16006975..7d7045e5c93673 100644 --- a/src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs +++ b/src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs @@ -3678,6 +3678,15 @@ private void getWasmWellKnownGlobals(ref CORINFO_WASM_WELLKNOWN_GLOBALS pWellKno pWellKnownGlobalsOut.tableBase = (CORINFO_WASM_GLOBAL_SYMBOL_STRUCT_*)ObjectToHandle(factory.GetWellKnownWasmGlobalSymbol(new(WasmWellKnownGlobalSymbolNode.TableBaseName))); pWellKnownGlobalsOut.asyncContinuation = (CORINFO_WASM_GLOBAL_SYMBOL_STRUCT_*)ObjectToHandle(factory.GetWellKnownWasmGlobalSymbol(new(WasmWellKnownGlobalSymbolNode.AsyncContinuationName))); } + + private CORINFO_WASM_TYPE_SYMBOL_STRUCT_* getWasmTypeSymbol(CorInfoWasmType* types, nuint typesSize) + { + CorInfoWasmType[] typeArray = new ReadOnlySpan(types, (int)typesSize).ToArray(); + + WasmTypeNode typeNode = _compilation.NodeFactory.WasmTypeNode(typeArray); + return (CORINFO_WASM_TYPE_SYMBOL_STRUCT_*)ObjectToHandle(typeNode); + } + private CORINFO_METHOD_STRUCT_* getAwaitReturnCall(CORINFO_METHOD_STRUCT_* callerHandle, CORINFO_CONTEXT_STRUCT** contextHandle, ref CORINFO_LOOKUP instArg) { instArg.lookupKind.needsRuntimeLookup = false; diff --git a/src/coreclr/tools/Common/JitInterface/WasmLowering.cs b/src/coreclr/tools/Common/JitInterface/WasmLowering.cs index 7f26a8ea3fc039..f9aba55a11ef7c 100644 --- a/src/coreclr/tools/Common/JitInterface/WasmLowering.cs +++ b/src/coreclr/tools/Common/JitInterface/WasmLowering.cs @@ -810,11 +810,13 @@ public static WasmSignature GetSignature(MethodSignature signature, LoweringFlag } } +#if READYTORUN if (!flags.HasFlag(LoweringFlags.IsUnmanagedCallersOnly)) { result.Add(pointerType); // PE entrypoint parameter (encoded via 'p' suffix) sigBuilder.Append('p'); } +#endif WasmResultType ps = new(result.ToArray()); WasmResultType ret = returnIsVoid ? new(Array.Empty()) diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/NodeFactory.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/NodeFactory.cs index 2b04541d7d741b..a25655b2f78860 100644 --- a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/NodeFactory.cs +++ b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/NodeFactory.cs @@ -1630,6 +1630,11 @@ public WasmTypeNode WasmTypeNode(MethodDesc desc) return _wasmTypeNodes.GetOrAdd(WasmLowering.GetSignature(desc).FuncType); } + public WasmTypeNode WasmTypeNode(CorInfoWasmType[] types) + { + return _wasmTypeNodes.GetOrAdd(WasmFuncType.FromCorInfoSignature(types)); + } + /// /// Returns alternative symbol name that object writer should produce for given symbols /// in addition to the regular one. diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs index 9f35b84c022184..f0f379a6eafa6e 100644 --- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs +++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs @@ -3733,14 +3733,6 @@ private bool notifyMethodInfoUsage(CORINFO_METHOD_STRUCT_* ftn) return _compilation.NodeFactory.CompilationModuleGroup.VersionsWithMethodBody(method); } - private CORINFO_WASM_TYPE_SYMBOL_STRUCT_* getWasmTypeSymbol(CorInfoWasmType* types, nuint typesSize) - { - CorInfoWasmType[] typeArray = new ReadOnlySpan(types, (int)typesSize).ToArray(); - - WasmTypeNode typeNode = _compilation.NodeFactory.WasmTypeNode(typeArray); - return (CORINFO_WASM_TYPE_SYMBOL_STRUCT_*)ObjectToHandle(typeNode); - } - #pragma warning disable CA1822 // Mark members as static private void getThreadLocalStaticInfo_NativeAOT(CORINFO_THREAD_STATIC_INFO_NATIVEAOT* pInfo) { diff --git a/src/coreclr/tools/aot/ILCompiler.RyuJit/Compiler/DependencyAnalysis/MethodCodeNode.cs b/src/coreclr/tools/aot/ILCompiler.RyuJit/Compiler/DependencyAnalysis/MethodCodeNode.cs index f8418a8d67befc..ad7dcee682698e 100644 --- a/src/coreclr/tools/aot/ILCompiler.RyuJit/Compiler/DependencyAnalysis/MethodCodeNode.cs +++ b/src/coreclr/tools/aot/ILCompiler.RyuJit/Compiler/DependencyAnalysis/MethodCodeNode.cs @@ -119,7 +119,7 @@ public ISymbolNode GetUnboxingThunkTarget(NodeFactory factory) public MethodExceptionHandlingInfoNode EHInfo => _ehInfo; // TODO-WASM: Appropriately extract funclet kinds from eh clause info - public FuncletKind[] GetFuncletKinds() => throw new NotImplementedException(); + public FuncletKind[] GetFuncletKinds() => []; public ISymbolNode GetAssociatedDataNode(NodeFactory factory) { diff --git a/src/coreclr/tools/aot/ILCompiler.RyuJit/JitInterface/CorInfoImpl.RyuJit.cs b/src/coreclr/tools/aot/ILCompiler.RyuJit/JitInterface/CorInfoImpl.RyuJit.cs index 23d0fd509dc85c..956677c2dc6b88 100644 --- a/src/coreclr/tools/aot/ILCompiler.RyuJit/JitInterface/CorInfoImpl.RyuJit.cs +++ b/src/coreclr/tools/aot/ILCompiler.RyuJit/JitInterface/CorInfoImpl.RyuJit.cs @@ -15,6 +15,7 @@ using ILCompiler; using ILCompiler.DependencyAnalysis; +using ILCompiler.DependencyAnalysis.Wasm; using System.Runtime.CompilerServices; #if SUPPORT_JIT @@ -2502,11 +2503,6 @@ private void getThreadLocalStaticInfo_NativeAOT(CORINFO_THREAD_STATIC_INFO_NATIV pInfo->tlsGetAddrFtnPtr = CreateConstLookupToSymbol(_compilation.NodeFactory.ExternFunctionSymbol(new Utf8String("__tls_get_addr"u8))); } - private CORINFO_WASM_TYPE_SYMBOL_STRUCT_* getWasmTypeSymbol(CorInfoWasmType* types, nuint typesSize) - { - throw new NotImplementedException(); - } - #pragma warning disable CA1822 // Mark members as static private bool notifyMethodInfoUsage(CORINFO_METHOD_STRUCT_* ftn) #pragma warning restore CA1822 // Mark members as static