Add typed-handle wrappers for the ORC v2 / LLJIT C-API

sources/LLVMSharp.Interop/Extensions/LLVMOrcDefinitionGeneratorRef.cs

@@ -0,0 +1,66 @@
+// Copyright (c) .NET Foundation and Contributors. All Rights Reserved. Licensed under the MIT License (MIT). See License.md in the repository root for more information.
+
+using System;
+
+namespace LLVMSharp.Interop;
+
+public unsafe partial struct LLVMOrcDefinitionGeneratorRef(IntPtr handle) : IDisposable, IEquatable<LLVMOrcDefinitionGeneratorRef>
+{
+    public IntPtr Handle = handle;
+
+    public static implicit operator LLVMOrcDefinitionGeneratorRef(LLVMOrcOpaqueDefinitionGenerator* value) => new LLVMOrcDefinitionGeneratorRef((IntPtr)value);
+
+    public static implicit operator LLVMOrcOpaqueDefinitionGenerator*(LLVMOrcDefinitionGeneratorRef value) => (LLVMOrcOpaqueDefinitionGenerator*)value.Handle;
+
+    public static bool operator ==(LLVMOrcDefinitionGeneratorRef left, LLVMOrcDefinitionGeneratorRef right) => left.Handle == right.Handle;
+
+    public static bool operator !=(LLVMOrcDefinitionGeneratorRef left, LLVMOrcDefinitionGeneratorRef right) => !(left == right);
+
+    public static LLVMOrcDefinitionGeneratorRef CreateCustomCAPIDefinitionGenerator(delegate* unmanaged[Cdecl]<LLVMOrcOpaqueDefinitionGenerator*, void*, LLVMOrcOpaqueLookupState**, LLVMOrcLookupKind, LLVMOrcOpaqueJITDylib*, LLVMOrcJITDylibLookupFlags, LLVMOrcCLookupSetElement*, nuint, LLVMOpaqueError*> F, void* Ctx, delegate* unmanaged[Cdecl]<void*, void> Dispose)
+        => LLVM.OrcCreateCustomCAPIDefinitionGenerator(F, Ctx, Dispose);
+
+    public static LLVMErrorRef CreateDynamicLibrarySearchGeneratorForProcess(out LLVMOrcDefinitionGeneratorRef Result, sbyte GlobalPrefix, delegate* unmanaged[Cdecl]<void*, LLVMOrcOpaqueSymbolStringPoolEntry*, int> Filter, void* FilterCtx)
+    {
+        fixed (LLVMOrcDefinitionGeneratorRef* pResult = &Result)
+        {
+            return LLVM.OrcCreateDynamicLibrarySearchGeneratorForProcess((LLVMOrcOpaqueDefinitionGenerator**)pResult, GlobalPrefix, Filter, FilterCtx);
+        }
+    }
+
+    public static LLVMErrorRef CreateDynamicLibrarySearchGeneratorForPath(out LLVMOrcDefinitionGeneratorRef Result, ReadOnlySpan<char> FileName, sbyte GlobalPrefix, delegate* unmanaged[Cdecl]<void*, LLVMOrcOpaqueSymbolStringPoolEntry*, int> Filter, void* FilterCtx)
+    {
+        using var marshaledFileName = new MarshaledString(FileName);
+
+        fixed (LLVMOrcDefinitionGeneratorRef* pResult = &Result)
+        {
+            return LLVM.OrcCreateDynamicLibrarySearchGeneratorForPath((LLVMOrcOpaqueDefinitionGenerator**)pResult, marshaledFileName, GlobalPrefix, Filter, FilterCtx);
+        }
+    }
+
+    public static LLVMErrorRef CreateStaticLibrarySearchGeneratorForPath(out LLVMOrcDefinitionGeneratorRef Result, LLVMOrcObjectLayerRef ObjLayer, ReadOnlySpan<char> FileName)
+    {
+        using var marshaledFileName = new MarshaledString(FileName);
+
+        fixed (LLVMOrcDefinitionGeneratorRef* pResult = &Result)
+        {
+            return LLVM.OrcCreateStaticLibrarySearchGeneratorForPath((LLVMOrcOpaqueDefinitionGenerator**)pResult, ObjLayer, marshaledFileName);
+        }
+    }
+
+    public void Dispose()
+    {
+        if (Handle != IntPtr.Zero)
+        {
+            LLVM.OrcDisposeDefinitionGenerator(this);
+            Handle = IntPtr.Zero;
+        }
+    }
+
+    public override readonly bool Equals(object? obj) => (obj is LLVMOrcDefinitionGeneratorRef other) && Equals(other);
+
+    public readonly bool Equals(LLVMOrcDefinitionGeneratorRef other) => this == other;
+
+    public override readonly int GetHashCode() => Handle.GetHashCode();
+
+    public override readonly string ToString() => $"{nameof(LLVMOrcDefinitionGeneratorRef)}: {Handle:X}";
+}

sources/LLVMSharp.Interop/Extensions/LLVMOrcDumpObjectsRef.cs

@@ -0,0 +1,53 @@
+// Copyright (c) .NET Foundation and Contributors. All Rights Reserved. Licensed under the MIT License (MIT). See License.md in the repository root for more information.
+
+using System;
+
+namespace LLVMSharp.Interop;
+
+public unsafe partial struct LLVMOrcDumpObjectsRef(IntPtr handle) : IDisposable, IEquatable<LLVMOrcDumpObjectsRef>
+{
+    public IntPtr Handle = handle;
+
+    public static implicit operator LLVMOrcDumpObjectsRef(LLVMOrcOpaqueDumpObjects* value) => new LLVMOrcDumpObjectsRef((IntPtr)value);
+
+    public static implicit operator LLVMOrcOpaqueDumpObjects*(LLVMOrcDumpObjectsRef value) => (LLVMOrcOpaqueDumpObjects*)value.Handle;
+
+    public static bool operator ==(LLVMOrcDumpObjectsRef left, LLVMOrcDumpObjectsRef right) => left.Handle == right.Handle;
+
+    public static bool operator !=(LLVMOrcDumpObjectsRef left, LLVMOrcDumpObjectsRef right) => !(left == right);
+
+    public static LLVMOrcDumpObjectsRef Create(string DumpDir, string IdentifierOverride) => Create(DumpDir.AsSpan(), IdentifierOverride.AsSpan());
+
+    public static LLVMOrcDumpObjectsRef Create(ReadOnlySpan<char> DumpDir, ReadOnlySpan<char> IdentifierOverride)
+    {
+        using var marshaledDumpDir = new MarshaledString(DumpDir);
+        using var marshaledIdentifierOverride = new MarshaledString(IdentifierOverride);
+        return LLVM.OrcCreateDumpObjects(marshaledDumpDir, marshaledIdentifierOverride);
+    }
+
+    // Dumps ObjBuffer and, on success, returns it (possibly replaced) through the ref parameter.
+    public readonly LLVMErrorRef CallOperator(ref LLVMMemoryBufferRef ObjBuffer)
+    {
+        fixed (LLVMMemoryBufferRef* pObjBuffer = &ObjBuffer)
+        {
+            return LLVM.OrcDumpObjects_CallOperator(this, (LLVMOpaqueMemoryBuffer**)pObjBuffer);
+        }
+    }
+
+    public void Dispose()
+    {
+        if (Handle != IntPtr.Zero)
+        {
+            LLVM.OrcDisposeDumpObjects(this);
+            Handle = IntPtr.Zero;
+        }
+    }
+
+    public override readonly bool Equals(object? obj) => (obj is LLVMOrcDumpObjectsRef other) && Equals(other);
+
+    public readonly bool Equals(LLVMOrcDumpObjectsRef other) => this == other;
+
+    public override readonly int GetHashCode() => Handle.GetHashCode();
+
+    public override readonly string ToString() => $"{nameof(LLVMOrcDumpObjectsRef)}: {Handle:X}";
+}

sources/LLVMSharp.Interop/Extensions/LLVMOrcExecutionSessionRef.cs

@@ -0,0 +1,75 @@
+// Copyright (c) .NET Foundation and Contributors. All Rights Reserved. Licensed under the MIT License (MIT). See License.md in the repository root for more information.
+
+using System;
+
+namespace LLVMSharp.Interop;
+
+public unsafe partial struct LLVMOrcExecutionSessionRef(IntPtr handle) : IEquatable<LLVMOrcExecutionSessionRef>
+{
+    public IntPtr Handle = handle;
+
+    public static implicit operator LLVMOrcExecutionSessionRef(LLVMOrcOpaqueExecutionSession* value) => new LLVMOrcExecutionSessionRef((IntPtr)value);
+
+    public static implicit operator LLVMOrcOpaqueExecutionSession*(LLVMOrcExecutionSessionRef value) => (LLVMOrcOpaqueExecutionSession*)value.Handle;
+
+    public static bool operator ==(LLVMOrcExecutionSessionRef left, LLVMOrcExecutionSessionRef right) => left.Handle == right.Handle;
+
+    public static bool operator !=(LLVMOrcExecutionSessionRef left, LLVMOrcExecutionSessionRef right) => !(left == right);
+
+    public readonly LLVMOrcSymbolStringPoolRef SymbolStringPool => (Handle != IntPtr.Zero) ? LLVM.OrcExecutionSessionGetSymbolStringPool(this) : default;
+
+    public readonly LLVMOrcJITDylibRef CreateBareJITDylib(string Name) => CreateBareJITDylib(Name.AsSpan());
+
+    public readonly LLVMOrcJITDylibRef CreateBareJITDylib(ReadOnlySpan<char> Name)
+    {
+        using var marshaledName = new MarshaledString(Name);
+        return LLVM.OrcExecutionSessionCreateBareJITDylib(this, marshaledName);
+    }
+
+    public readonly LLVMErrorRef CreateJITDylib(out LLVMOrcJITDylibRef Result, string Name) => CreateJITDylib(out Result, Name.AsSpan());
+
+    public readonly LLVMErrorRef CreateJITDylib(out LLVMOrcJITDylibRef Result, ReadOnlySpan<char> Name)
+    {
+        using var marshaledName = new MarshaledString(Name);
+
+        fixed (LLVMOrcJITDylibRef* pResult = &Result)
+        {
+            return LLVM.OrcExecutionSessionCreateJITDylib(this, (LLVMOrcOpaqueJITDylib**)pResult, marshaledName);
+        }
+    }
+
+    public readonly LLVMOrcObjectLayerRef CreateRTDyldObjectLinkingLayerWithSectionMemoryManager() => LLVM.OrcCreateRTDyldObjectLinkingLayerWithSectionMemoryManager(this);
+
+    public readonly LLVMOrcObjectLayerRef CreateRTDyldObjectLinkingLayerWithMCJITMemoryManagerLikeCallbacks(void* CreateContextCtx, delegate* unmanaged[Cdecl]<void*, void*> CreateContext, delegate* unmanaged[Cdecl]<void*, void> NotifyTerminating, delegate* unmanaged[Cdecl]<void*, nuint, uint, uint, sbyte*, byte*> AllocateCodeSection, delegate* unmanaged[Cdecl]<void*, nuint, uint, uint, sbyte*, int, byte*> AllocateDataSection, delegate* unmanaged[Cdecl]<void*, sbyte**, int> FinalizeMemory, delegate* unmanaged[Cdecl]<void*, void> Destroy)
+        => LLVM.OrcCreateRTDyldObjectLinkingLayerWithMCJITMemoryManagerLikeCallbacks(this, CreateContextCtx, CreateContext, NotifyTerminating, AllocateCodeSection, AllocateDataSection, FinalizeMemory, Destroy);
+
+    public override readonly bool Equals(object? obj) => (obj is LLVMOrcExecutionSessionRef other) && Equals(other);
+
+    public readonly bool Equals(LLVMOrcExecutionSessionRef other) => this == other;
+
+    public override readonly int GetHashCode() => Handle.GetHashCode();
+
+    public readonly LLVMOrcJITDylibRef GetJITDylibByName(string Name) => GetJITDylibByName(Name.AsSpan());
+
+    public readonly LLVMOrcJITDylibRef GetJITDylibByName(ReadOnlySpan<char> Name)
+    {
+        using var marshaledName = new MarshaledString(Name);
+        return LLVM.OrcExecutionSessionGetJITDylibByName(this, marshaledName);
+    }
+
+    public readonly LLVMOrcSymbolStringPoolEntryRef Intern(string Name) => Intern(Name.AsSpan());
+
+    public readonly LLVMOrcSymbolStringPoolEntryRef Intern(ReadOnlySpan<char> Name)
+    {
+        using var marshaledName = new MarshaledString(Name);
+        return LLVM.OrcExecutionSessionIntern(this, marshaledName);
+    }
+
+    // Takes ownership of the symbols in the lookup set. HandleResult is called with the result.
+    public readonly void Lookup(LLVMOrcLookupKind K, LLVMOrcCJITDylibSearchOrderElement* SearchOrder, nuint SearchOrderSize, LLVMOrcCLookupSetElement* Symbols, nuint SymbolsSize, delegate* unmanaged[Cdecl]<LLVMOpaqueError*, LLVMOrcCSymbolMapPair*, nuint, void*, void> HandleResult, void* Ctx)
+        => LLVM.OrcExecutionSessionLookup(this, K, SearchOrder, SearchOrderSize, Symbols, SymbolsSize, HandleResult, Ctx);
+
+    public readonly void SetErrorReporter(delegate* unmanaged[Cdecl]<void*, LLVMOpaqueError*, void> ReportError, void* Ctx) => LLVM.OrcExecutionSessionSetErrorReporter(this, ReportError, Ctx);
+
+    public override readonly string ToString() => $"{nameof(LLVMOrcExecutionSessionRef)}: {Handle:X}";
+}

sources/LLVMSharp.Interop/Extensions/LLVMOrcIRTransformLayerRef.cs

@@ -0,0 +1,31 @@
+// Copyright (c) .NET Foundation and Contributors. All Rights Reserved. Licensed under the MIT License (MIT). See License.md in the repository root for more information.
+
+using System;
+
+namespace LLVMSharp.Interop;
+
+public unsafe partial struct LLVMOrcIRTransformLayerRef(IntPtr handle) : IEquatable<LLVMOrcIRTransformLayerRef>
+{
+    public IntPtr Handle = handle;
+
+    public static implicit operator LLVMOrcIRTransformLayerRef(LLVMOrcOpaqueIRTransformLayer* value) => new LLVMOrcIRTransformLayerRef((IntPtr)value);
+
+    public static implicit operator LLVMOrcOpaqueIRTransformLayer*(LLVMOrcIRTransformLayerRef value) => (LLVMOrcOpaqueIRTransformLayer*)value.Handle;
+
+    public static bool operator ==(LLVMOrcIRTransformLayerRef left, LLVMOrcIRTransformLayerRef right) => left.Handle == right.Handle;
+
+    public static bool operator !=(LLVMOrcIRTransformLayerRef left, LLVMOrcIRTransformLayerRef right) => !(left == right);
+
+    // Takes ownership of MR and TSM.
+    public readonly void Emit(LLVMOrcMaterializationResponsibilityRef MR, LLVMOrcThreadSafeModuleRef TSM) => LLVM.OrcIRTransformLayerEmit(this, MR, TSM);
+
+    public override readonly bool Equals(object? obj) => (obj is LLVMOrcIRTransformLayerRef other) && Equals(other);
+
+    public readonly bool Equals(LLVMOrcIRTransformLayerRef other) => this == other;
+
+    public override readonly int GetHashCode() => Handle.GetHashCode();
+
+    public readonly void SetTransform(delegate* unmanaged[Cdecl]<void*, LLVMOrcOpaqueThreadSafeModule**, LLVMOrcOpaqueMaterializationResponsibility*, LLVMOpaqueError*> TransformFunction, void* Ctx) => LLVM.OrcIRTransformLayerSetTransform(this, TransformFunction, Ctx);
+
+    public override readonly string ToString() => $"{nameof(LLVMOrcIRTransformLayerRef)}: {Handle:X}";
+}

sources/LLVMSharp.Interop/Extensions/LLVMOrcIndirectStubsManagerRef.cs

@@ -0,0 +1,43 @@
+// Copyright (c) .NET Foundation and Contributors. All Rights Reserved. Licensed under the MIT License (MIT). See License.md in the repository root for more information.
+
+using System;
+
+namespace LLVMSharp.Interop;
+
+public unsafe partial struct LLVMOrcIndirectStubsManagerRef(IntPtr handle) : IDisposable, IEquatable<LLVMOrcIndirectStubsManagerRef>
+{
+    public IntPtr Handle = handle;
+
+    public static implicit operator LLVMOrcIndirectStubsManagerRef(LLVMOrcOpaqueIndirectStubsManager* value) => new LLVMOrcIndirectStubsManagerRef((IntPtr)value);
+
+    public static implicit operator LLVMOrcOpaqueIndirectStubsManager*(LLVMOrcIndirectStubsManagerRef value) => (LLVMOrcOpaqueIndirectStubsManager*)value.Handle;
+
+    public static bool operator ==(LLVMOrcIndirectStubsManagerRef left, LLVMOrcIndirectStubsManagerRef right) => left.Handle == right.Handle;
+
+    public static bool operator !=(LLVMOrcIndirectStubsManagerRef left, LLVMOrcIndirectStubsManagerRef right) => !(left == right);
+
+    public static LLVMOrcIndirectStubsManagerRef CreateLocal(string TargetTriple) => CreateLocal(TargetTriple.AsSpan());
+
+    public static LLVMOrcIndirectStubsManagerRef CreateLocal(ReadOnlySpan<char> TargetTriple)
+    {
+        using var marshaledTriple = new MarshaledString(TargetTriple);
+        return LLVM.OrcCreateLocalIndirectStubsManager(marshaledTriple);
+    }
+
+    public void Dispose()
+    {
+        if (Handle != IntPtr.Zero)
+        {
+            LLVM.OrcDisposeIndirectStubsManager(this);
+            Handle = IntPtr.Zero;
+        }
+    }
+
+    public override readonly bool Equals(object? obj) => (obj is LLVMOrcIndirectStubsManagerRef other) && Equals(other);
+
+    public readonly bool Equals(LLVMOrcIndirectStubsManagerRef other) => this == other;
+
+    public override readonly int GetHashCode() => Handle.GetHashCode();
+
+    public override readonly string ToString() => $"{nameof(LLVMOrcIndirectStubsManagerRef)}: {Handle:X}";
+}

sources/LLVMSharp.Interop/Extensions/LLVMOrcJITDylibRef.cs

@@ -0,0 +1,38 @@
+// Copyright (c) .NET Foundation and Contributors. All Rights Reserved. Licensed under the MIT License (MIT). See License.md in the repository root for more information.
+
+using System;
+
+namespace LLVMSharp.Interop;
+
+public unsafe partial struct LLVMOrcJITDylibRef(IntPtr handle) : IEquatable<LLVMOrcJITDylibRef>
+{
+    public IntPtr Handle = handle;
+
+    public static implicit operator LLVMOrcJITDylibRef(LLVMOrcOpaqueJITDylib* value) => new LLVMOrcJITDylibRef((IntPtr)value);
+
+    public static implicit operator LLVMOrcOpaqueJITDylib*(LLVMOrcJITDylibRef value) => (LLVMOrcOpaqueJITDylib*)value.Handle;
+
+    public static bool operator ==(LLVMOrcJITDylibRef left, LLVMOrcJITDylibRef right) => left.Handle == right.Handle;
+
+    public static bool operator !=(LLVMOrcJITDylibRef left, LLVMOrcJITDylibRef right) => !(left == right);
+
+    // Takes ownership of DG.
+    public readonly void AddGenerator(LLVMOrcDefinitionGeneratorRef DG) => LLVM.OrcJITDylibAddGenerator(this, DG);
+
+    public readonly LLVMErrorRef Clear() => LLVM.OrcJITDylibClear(this);
+
+    public readonly LLVMOrcResourceTrackerRef CreateResourceTracker() => LLVM.OrcJITDylibCreateResourceTracker(this);
+
+    // Takes ownership of MU.
+    public readonly LLVMErrorRef Define(LLVMOrcMaterializationUnitRef MU) => LLVM.OrcJITDylibDefine(this, MU);
+
+    public override readonly bool Equals(object? obj) => (obj is LLVMOrcJITDylibRef other) && Equals(other);
+
+    public readonly bool Equals(LLVMOrcJITDylibRef other) => this == other;
+
+    public readonly LLVMOrcResourceTrackerRef GetDefaultResourceTracker() => LLVM.OrcJITDylibGetDefaultResourceTracker(this);
+
+    public override readonly int GetHashCode() => Handle.GetHashCode();
+
+    public override readonly string ToString() => $"{nameof(LLVMOrcJITDylibRef)}: {Handle:X}";
+}

sources/LLVMSharp.Interop/Extensions/LLVMOrcJITTargetMachineBuilderRef.cs

@@ -0,0 +1,72 @@
+// Copyright (c) .NET Foundation and Contributors. All Rights Reserved. Licensed under the MIT License (MIT). See License.md in the repository root for more information.
+
+using System;
+
+namespace LLVMSharp.Interop;
+
+public unsafe partial struct LLVMOrcJITTargetMachineBuilderRef(IntPtr handle) : IDisposable, IEquatable<LLVMOrcJITTargetMachineBuilderRef>
+{
+    public IntPtr Handle = handle;
+
+    public static implicit operator LLVMOrcJITTargetMachineBuilderRef(LLVMOrcOpaqueJITTargetMachineBuilder* value) => new LLVMOrcJITTargetMachineBuilderRef((IntPtr)value);
+
+    public static implicit operator LLVMOrcOpaqueJITTargetMachineBuilder*(LLVMOrcJITTargetMachineBuilderRef value) => (LLVMOrcOpaqueJITTargetMachineBuilder*)value.Handle;
+
+    public static bool operator ==(LLVMOrcJITTargetMachineBuilderRef left, LLVMOrcJITTargetMachineBuilderRef right) => left.Handle == right.Handle;
+
+    public static bool operator !=(LLVMOrcJITTargetMachineBuilderRef left, LLVMOrcJITTargetMachineBuilderRef right) => !(left == right);
+
+    public readonly string TargetTriple
+    {
+        get
+        {
+            if (Handle == IntPtr.Zero)
+            {
+                return string.Empty;
+            }
+
+            var pTriple = LLVM.OrcJITTargetMachineBuilderGetTargetTriple(this);
+
+            // The caller owns the returned string and must free it with LLVM.DisposeMessage.
+            var result = SpanExtensions.AsString(pTriple);
+            LLVM.DisposeMessage(pTriple);
+            return result;
+        }
+    }
+
+    public static LLVMErrorRef DetectHost(out LLVMOrcJITTargetMachineBuilderRef Result)
+    {
+        fixed (LLVMOrcJITTargetMachineBuilderRef* pResult = &Result)
+        {
+            return LLVM.OrcJITTargetMachineBuilderDetectHost((LLVMOrcOpaqueJITTargetMachineBuilder**)pResult);
+        }
+    }
+
+    // Takes ownership of TM.
+    public static LLVMOrcJITTargetMachineBuilderRef CreateFromTargetMachine(LLVMTargetMachineRef TM) => LLVM.OrcJITTargetMachineBuilderCreateFromTargetMachine(TM);
+
+    public void Dispose()
+    {
+        if (Handle != IntPtr.Zero)
+        {
+            LLVM.OrcDisposeJITTargetMachineBuilder(this);
+            Handle = IntPtr.Zero;
+        }
+    }
+
+    public override readonly bool Equals(object? obj) => (obj is LLVMOrcJITTargetMachineBuilderRef other) && Equals(other);
+
+    public readonly bool Equals(LLVMOrcJITTargetMachineBuilderRef other) => this == other;
+
+    public override readonly int GetHashCode() => Handle.GetHashCode();
+
+    public readonly void SetTargetTriple(string TargetTriple) => SetTargetTriple(TargetTriple.AsSpan());
+
+    public readonly void SetTargetTriple(ReadOnlySpan<char> TargetTriple)
+    {
+        using var marshaledTriple = new MarshaledString(TargetTriple);
+        LLVM.OrcJITTargetMachineBuilderSetTargetTriple(this, marshaledTriple);
+    }
+
+    public override readonly string ToString() => $"{nameof(LLVMOrcJITTargetMachineBuilderRef)}: {Handle:X}";
+}