Simplification of array parameters for interop calls (#255)

- To say that the AOT source generator marshaling was under documented would be the understatement of the century. Sadly, that includes marshaling of arrays, especially arrays of safe handles (or in this case global Handles)

This PR contains interop wrapper function that take care of the heavy lifting as needed.

Co-authored-by: smaillet <25911635+smaillet@users.noreply.github.com>

Author: smaillet

src/Interop/InteropTests/DebugRecordTests.cs

@@ -73,7 +73,7 @@ public void DebugRecordEnumerationSucceeds( )
 
             LLVMMetadataRef int32PtrDiType = LLVMDIBuilderCreatePointerType(diBuilder, int32DiType, 32, 0, 0, "int*"u8);
             LLVMMetadataRef emptyExpression = LLVMDIBuilderCreateExpression(diBuilder, []);
-            LLVMMetadataRef diFuncType = LLVMDIBuilderCreateSubroutineType(diBuilder, default, [], 0, LLVMDIFlags.LLVMDIFlagPrivate);
+            LLVMMetadataRef diFuncType = LLVMDIBuilderCreateSubroutineType(diBuilder, default, [], LLVMDIFlags.LLVMDIFlagPrivate);
             LLVMMetadataRef scope = LLVMDIBuilderCreateFunction(
                 diBuilder,
                 Scope: default,

src/Interop/Ubiquity.NET.Llvm.Interop/ABI/llvm-c/Core.cs

@@ -710,7 +710,6 @@ public static void LLVMSetSourceFileName( LLVMModuleRefAlias M, LazyEncodedStrin
         // so the types are problematic in full verification. In reality, len will NOT exceed the uint.MaxValue
         [LibraryImport( LibraryName )]
         [UnmanagedCallConv( CallConvs = [ typeof( CallConvCdecl ) ] )]
-        [return: MarshalUsing( CountElementName = nameof( Len ) )]
         public static unsafe partial LLVMModuleFlagEntry LLVMCopyModuleFlagsMetadata( LLVMModuleRefAlias M, out nuint Len );
 
         [LibraryImport( LibraryName )]
@@ -3055,12 +3054,32 @@ uint NumArgs
         [UnmanagedCallConv( CallConvs = [ typeof( CallConvCdecl ) ] )]
         public static unsafe partial uint LLVMGetCallSiteAttributeCount( LLVMValueRef C, LLVMAttributeIndex Idx );
 
+        public static LLVMAttributeRef[] LLVMGetCallSiteAttributes(LLVMValueRef c, LLVMAttributeIndex index)
+        {
+            uint count = LLVMGetCallSiteAttributeCount(c, index );
+            if(count == 0)
+            {
+                return [];
+            }
+
+            var retVal = new LLVMAttributeRef[ count ];
+            unsafe
+            {
+                fixed(LLVMAttributeRef* pBuf = retVal)
+                {
+                    LLVMGetCallSiteAttributes( c, index, pBuf );
+                }
+            }
+
+            return retVal;
+        }
+
         // size of Attrs must contain enough room for LLVMGetCallSiteAttributeCount() elements or memory corruption
         // will occur. The native code only deals with a pointer and assumes it points to a region big enough to
         // hold the correct amount.
         [LibraryImport( LibraryName )]
         [UnmanagedCallConv( CallConvs = [ typeof( CallConvCdecl ) ] )]
-        public static unsafe partial void LLVMGetCallSiteAttributes(
+        private static unsafe partial void LLVMGetCallSiteAttributes(
             LLVMValueRef C,
             LLVMAttributeIndex Idx,
             /*LLVMAttributeRef[LLVMGetCallSiteAttributeCount(C, Idx)]*/LLVMAttributeRef* Attrs
@@ -3401,6 +3420,7 @@ private static unsafe partial LLVMValueRef LLVMBuildCallBr(
             LazyEncodedString Name
             );
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static LLVMValueRef LLVMBuildInvoke2(
             LLVMBuilderRef builder,
             LLVMTypeRef typeRef,
@@ -3434,9 +3454,40 @@ private static unsafe partial LLVMValueRef LLVMBuildInvoke2(
             LLVMBasicBlockRef Catch,
             LazyEncodedString Name );
 
+        public static LLVMValueRef LLVMBuildInvokeWithOperandBundles(
+            LLVMBuilderRef builder,
+            LLVMTypeRef typeRef,
+            LLVMValueRef functionValue,
+            LLVMValueRef[] args,
+            LLVMBasicBlockRef @then,
+            LLVMBasicBlockRef @catch,
+            LLVMOperandBundleRef[] bundles,
+            LazyEncodedString name
+            )
+        {
+            unsafe
+            {
+                return RefHandleMarshaller.WithNativePointer(
+                            bundles,
+                            ( p, size ) => LLVMBuildInvokeWithOperandBundles(
+                                               builder,
+                                               typeRef,
+                                               functionValue,
+                                               args,
+                                               checked((uint)args.Length),
+                                               @then,
+                                               @catch,
+                                               p,
+                                               checked((uint)size),
+                                               name
+                                               )
+                       );
+            }
+        }
+
         [LibraryImport( LibraryName )]
         [UnmanagedCallConv( CallConvs = [ typeof( CallConvCdecl ) ] )]
-        public static unsafe partial LLVMValueRef LLVMBuildInvokeWithOperandBundles(
+        private static unsafe partial LLVMValueRef LLVMBuildInvokeWithOperandBundles(
             LLVMBuilderRef B,
             LLVMTypeRef Ty,
             LLVMValueRef Fn,
@@ -3480,6 +3531,7 @@ LazyEncodedString Name
         [UnmanagedCallConv( CallConvs = [ typeof( CallConvCdecl ) ] )]
         public static unsafe partial LLVMValueRef LLVMBuildCatchRet( LLVMBuilderRef B, LLVMValueRef CatchPad, LLVMBasicBlockRef BB );
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static LLVMValueRef LLVMBuildCatchPad(
             LLVMBuilderRef B,
             LLVMValueRef ParentPad,
@@ -3503,14 +3555,23 @@ private static unsafe partial LLVMValueRef LLVMBuildCatchPad(
             LazyEncodedString Name
             );
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static LLVMValueRef LLVMBuildCleanupPad(
+            LLVMBuilderRef B,
+            LLVMValueRef ParentPad,
+            LLVMValueRef[] Args,
+            LazyEncodedString Name
+            )
+        {
+            return LLVMBuildCleanupPad(B, ParentPad, Args, checked((uint)Args.Length), Name);
+        }
+
         [LibraryImport( LibraryName )]
         [UnmanagedCallConv( CallConvs = [ typeof( CallConvCdecl ) ] )]
-        public static unsafe partial LLVMValueRef LLVMBuildCleanupPad(
+        private static unsafe partial LLVMValueRef LLVMBuildCleanupPad(
             LLVMBuilderRef B,
             LLVMValueRef ParentPad,
-
-            // No marshalling attribute exists to set the length, the length of this array MUST be at least NumArgs
-            [In] LLVMValueRef[] Args,
+            [In] LLVMValueRef[] Args, // the length of this array MUST be at least NumArgs
             uint NumArgs,
             LazyEncodedString Name
             );
@@ -3587,7 +3648,7 @@ public static LLVMBasicBlockRef[] LLVMGetHandlers( LLVMValueRef CatchSwitch )
         // Array provided for 'Handlers' must be at least (LLVMGetNumHandlers()) large
         // Use of generated marshalling is VERY inefficient as it doesn't know
         // that a LLVMBasicBlockRef is reinterpret_cast<nint> compatible.
-        // and tries to use a buffer array to `marshal` between forms even though
+        // and tries to use a retVal array to `marshal` between forms even though
         // they have the exact same bit pattern
         [LibraryImport( LibraryName )]
         [UnmanagedCallConv( CallConvs = [ typeof( CallConvCdecl ) ] )]
@@ -4006,9 +4067,36 @@ LazyEncodedString Name
         [UnmanagedCallConv( CallConvs = [ typeof( CallConvCdecl ) ] )]
         public static unsafe partial LLVMValueRef LLVMBuildCall2( LLVMBuilderRef B, LLVMTypeRef _1, LLVMValueRef Fn, [In] LLVMValueRef[] Args, uint NumArgs, LazyEncodedString Name );
 
+        public static LLVMValueRef LLVMBuildCallWithOperandBundles(
+            LLVMBuilderRef B,
+            LLVMTypeRef _1,
+            LLVMValueRef Fn,
+            LLVMValueRef[] Args,
+            LLVMOperandBundleRef[] Bundles,
+            LazyEncodedString Name
+            )
+        {
+            unsafe
+            {
+                return RefHandleMarshaller.WithNativePointer(
+                            Bundles,
+                            ( p, size ) => LLVMBuildCallWithOperandBundles(
+                                               B,
+                                               _1,
+                                               Fn,
+                                               Args,
+                                               checked((uint)Args.Length),
+                                               p,
+                                               checked((uint)size),
+                                               Name
+                                               )
+                       );
+            }
+        }
+
         [LibraryImport( LibraryName )]
         [UnmanagedCallConv( CallConvs = [ typeof( CallConvCdecl ) ] )]
-        public static unsafe partial LLVMValueRef LLVMBuildCallWithOperandBundles(
+        private static unsafe partial LLVMValueRef LLVMBuildCallWithOperandBundles(
             LLVMBuilderRef B,
             LLVMTypeRef _1,
             LLVMValueRef Fn,
@@ -4234,8 +4322,8 @@ public static unsafe partial LLVMStatus LLVMCreateMemoryBufferWithContentsOfFile
         [UnmanagedCallConv( CallConvs = [ typeof( CallConvCdecl ) ] )]
         public static unsafe partial LLVMStatus LLVMCreateMemoryBufferWithSTDIN( out LLVMMemoryBufferRef OutMemBuf, out string OutMessage );
 
-        // NOTE: This does NOT use an array as a param as it MUST remain valid and fixed for the lifetime of this
-        // buffer ref. That is it builds a reference to the data - NOT a copy.
+        // NOTE: This does NOT use an array or span as a param as the data MUST remain valid ***and*** fixed for the lifetime of this
+        // retVal ref. That is this builds a MemoryBuffer with a reference to the data - NOT a copy of it!
         [LibraryImport( LibraryName )]
         [UnmanagedCallConv( CallConvs = [ typeof( CallConvCdecl ) ] )]
         public static unsafe partial LLVMMemoryBufferRef LLVMCreateMemoryBufferWithMemoryRange(

src/Interop/Ubiquity.NET.Llvm.Interop/ABI/llvm-c/DebugInfo.cs

@@ -414,9 +414,22 @@ public static unsafe partial LLVMMetadataRef LLVMDIBuilderCreateImportedModuleFr
             uint Line
             );
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static LLVMMetadataRef LLVMDIBuilderCreateImportedModuleFromAlias(
+            LLVMDIBuilderRef Builder,
+            LLVMMetadataRef Scope,
+            LLVMMetadataRef ImportedEntity,
+            LLVMMetadataRef File,
+            uint Line,
+            LLVMMetadataRef[] Elements
+            )
+        {
+            return LLVMDIBuilderCreateImportedModuleFromAlias(Builder, Scope, ImportedEntity, File, Line, Elements, checked((uint)Elements.Length));
+        }
+
         [LibraryImport( LibraryName )]
         [UnmanagedCallConv( CallConvs = [ typeof( CallConvCdecl ) ] )]
-        public static unsafe partial LLVMMetadataRef LLVMDIBuilderCreateImportedModuleFromAlias(
+        private static unsafe partial LLVMMetadataRef LLVMDIBuilderCreateImportedModuleFromAlias(
             LLVMDIBuilderRef Builder,
             LLVMMetadataRef Scope,
             LLVMMetadataRef ImportedEntity,
@@ -426,9 +439,22 @@ public static unsafe partial LLVMMetadataRef LLVMDIBuilderCreateImportedModuleFr
             uint NumElements // NumElements MUST be <= Elements.Length
             );
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static LLVMMetadataRef LLVMDIBuilderCreateImportedModuleFromModule(
+            LLVMDIBuilderRef Builder,
+            LLVMMetadataRef Scope,
+            LLVMMetadataRef M,
+            LLVMMetadataRef File,
+            uint Line,
+            LLVMMetadataRef[] Elements
+            )
+        {
+            return LLVMDIBuilderCreateImportedModuleFromModule(Builder, Scope, M, File, Line, Elements, checked((uint)Elements.Length));
+        }
+
         [LibraryImport( LibraryName )]
         [UnmanagedCallConv( CallConvs = [ typeof( CallConvCdecl ) ] )]
-        public static unsafe partial LLVMMetadataRef LLVMDIBuilderCreateImportedModuleFromModule(
+        private static unsafe partial LLVMMetadataRef LLVMDIBuilderCreateImportedModuleFromModule(
             LLVMDIBuilderRef Builder,
             LLVMMetadataRef Scope,
             LLVMMetadataRef M,
@@ -559,9 +585,20 @@ private static unsafe partial LLVMMetadataRef LLVMDIBuilderGetOrCreateTypeArray(
             nuint NumElements // NumElements MUST be <= Data.Length
             );
 
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static LLVMMetadataRef LLVMDIBuilderCreateSubroutineType(
+            LLVMDIBuilderRef Builder,
+            LLVMMetadataRef File,
+            LLVMMetadataRef[] ParameterTypes,
+            LLVMDIFlags Flags
+            )
+        {
+            return LLVMDIBuilderCreateSubroutineType(Builder, File, ParameterTypes, checked((uint)ParameterTypes.Length), Flags);
+        }
+
         [LibraryImport( LibraryName )]
         [UnmanagedCallConv( CallConvs = [ typeof( CallConvCdecl ) ] )]
-        public static unsafe partial LLVMMetadataRef LLVMDIBuilderCreateSubroutineType(
+        private static unsafe partial LLVMMetadataRef LLVMDIBuilderCreateSubroutineType(
             LLVMDIBuilderRef Builder,
             LLVMMetadataRef File,
             [In] LLVMMetadataRef[] ParameterTypes,
@@ -602,7 +639,12 @@ private static unsafe partial LLVMMetadataRef LLVMDIBuilderCreateMacro(
 
         [LibraryImport( LibraryName )]
         [UnmanagedCallConv( CallConvs = [ typeof( CallConvCdecl ) ] )]
-        public static unsafe partial LLVMMetadataRef LLVMDIBuilderCreateTempMacroFile( LLVMDIBuilderRef Builder, LLVMMetadataRef ParentMacroFile, uint Line, LLVMMetadataRef File );
+        public static unsafe partial LLVMMetadataRef LLVMDIBuilderCreateTempMacroFile(
+            LLVMDIBuilderRef Builder,
+            LLVMMetadataRef ParentMacroFile,
+            uint Line,
+            LLVMMetadataRef File
+            );
 
         [MethodImpl( MethodImplOptions.AggressiveInlining )]
         public static LLVMMetadataRef LLVMDIBuilderCreateEnumerator(
@@ -1248,7 +1290,7 @@ public static LLVMMetadataRef LLVMDIBuilderCreateClassType(
             UInt64 OffsetInBits,
             LLVMDIFlags Flags,
             LLVMMetadataRef DerivedFrom,
-            [In] LLVMMetadataRef[] Elements,
+            LLVMMetadataRef[] Elements,
             LLVMMetadataRef VTableHolder,
             LLVMMetadataRef TemplateParamsNode,
             LazyEncodedString UniqueIdentifier

src/Interop/Ubiquity.NET.Llvm.Interop/ABI/llvm-c/Disassembler.cs

@@ -125,14 +125,15 @@ LLVMSymbolLookupCallback SymbolLookUp
         [return: MarshalAs( UnmanagedType.Bool )]
         public static unsafe partial bool LLVMSetDisasmOptions( LLVMDisasmContextRef DC, UInt64 Options );
 
+        // OutString is a pre-allocated buffer, OutStringSize is [In] param to indicate how big it is. (Text is Truncated if not big enough)
         [LibraryImport( LibraryName )]
         [UnmanagedCallConv( CallConvs = [ typeof( CallConvCdecl ) ] )]
         public static unsafe partial nuint LLVMDisasmInstruction(
             LLVMDisasmContextRef DC,
             byte* Bytes,
             UInt64 BytesSize,
             UInt64 PC,
-            byte* OutString, nuint OutStringSize // OutString is a pre-allocated buffer, size is how big it is. (Truncated if not big enough)
+            byte* OutString, nuint OutStringSize
             );
     }
 }

src/Interop/Ubiquity.NET.Llvm.Interop/ABI/llvm-c/DisassemblerTypes.cs

@@ -6,6 +6,10 @@
 
 namespace Ubiquity.NET.Llvm.Interop
 {
+    // NOTE: these are intentionally, NOT record structs as those do NOT allow unsafe types as fields (CS8908)
+    // Sadly, there is a bug where that error won't show in an IDE so it might look safe/OK until you build
+    // (see: https://github.com/dotnet/roslyn/issues/58878)
+
     [StructLayout( LayoutKind.Sequential )]
     public unsafe readonly struct LLVMOpInfoSymbol1
         : IEquatable<LLVMOpInfoSymbol1>