Question

I’m trying to wrap a C++ library (libclang) into a C# wrapper, using PInvoke.

Everything was shiny, until I tried to call a C++ method that returns a struct.
I did everything by the book, but when this method gets called, I get AccessViolationException.

Now, I read that it’s probably because there’s something messed up with the memory image of the objects. I checked and doublechecked if I’ve put all the arrtibutes and what nots everywhere but the Exception won’t go away. (I’ve been looking at this code for hours, so I may have missed some things, you guys don’t).

The C++ part (not my code, but I’m sure that it works):

CXString clang_formatDiagnostic(CXDiagnostic Diagnostic, unsigned Options) {

/* Parse the hell out of a lot of data, an then make a string
   In the end, string gets wrapped in a custom struct: CXString.
 */

    return createCXString(Out.str(), true);

}

Here’s CXString:

typedef struct {
  void *data;
  unsigned private_flags;
} CXString;

So I have my C# classes to represent the wrapped C++ originals:

public class Diagnostic 
    {
        private IntPtr _nativeObject;
        internal IntPtr NativeObject { get { return _nativeObject; } }

        [DllImport("libclang.dll", EntryPoint = "clang_formatDiagnostic")]
        [return: MarshalAs(UnmanagedType.LPStruct)]
        private static extern CXString FormatDiagnostic(IntPtr diag, uint options);

        public Diagnostic(IntPtr native)
        {
            _nativeObject = native;
        }

        public string GetString(DiagnosticDisplayOptions options = DiagnosticDisplayOptions.DisplaySourceLocation)
        {
            var cxstr = FormatDiagnostic(_nativeObject, (uint)options); //<-- I get the exception here
            return cxstr.GetString();
        }
    }

The functions I need are also implemented in a C taste (global) so, I can make an impression of OO in my C# classes, but in fact I store the IntPtr representations of the C++ objects (_nativeObject). So I’m pretty sure, that the object stored in the _nativeObject is in fact an CXDiagnostic (I got the reference returned from another function of the same library).

The actual object that I’m trying to use with FormatDiagnostic method gets initialized from the constructor of another wrapper class (TranslationUnit):

public TranslationUnit(/*lots of params to init the unit*/)
    {
        //... there are some int conversions and initialization failsafe codes here

        //this is a property of TranslationUnit
        Diagnostics = new List<Diagnostic>();

        //GetDiagnosticsCount is also PInvoke to count CXDiagnostic objects related to the TranslationUnit
        var dgCnt = (int)GetDiagnosticsCount(_nativeObject);
        for (int i = 0; i < dgCnt; i++)
        {
            //GetDiagnostic is also PInvoke, gets the CXDiagnostic at the given index
            var diag_ptr = GetDiagnostic(_nativeObject, (uint)i);
            Diagnostics.Add(new Diagnostic(diag_ptr));
        }
        //up until now, all the calls seem to work
        //I get the expected count of diagnostics and none of the other 
        //PInvoke calls throw exceptions. They use IntPtrs, but none of them
        //use structs.
    }

So as the MSDN tutorial suggested, I’ve made a C# class to Marshal the CXString struct into, and it looks like this:

[StructLayout(LayoutKind.Sequential)]
public class CXString
{
    public IntPtr data;
    public uint private_flags;
}

I get the AccessViolationException when the code reaches FormatDiagnostic call.
Any tips where it could have gone wrong?

EDIT:

CXDiagnostic is a pointer type in the original C++ code:

typedef void *CXDiagnostic;

Answer 1

I think marshalling to LPStruct is not proper here and the CXString class needs to be struct.

Try the following code:

public class Diagnostic 
{
    ...
    [DllImport("libclang.dll", EntryPoint = "clang_formatDiagnostic")]
    private static extern CXString FormatDiagnostic(IntPtr diag, uint options);
    ...
}

[StructLayout(LayoutKind.Sequential)]
public struct CXString
{
    public IntPtr data;
    public uint private_flags;
}

Also, you should take care of the calling convention (StdCall by default, but for example pure C use Cdecl) and the struct byte alignment.