Crash in debug mode (F5) when calling a native C++ method

Question

I am trying to call a C++ method by using LoadLibrary, GetProcAddress and GetDelegateForFunctionPointer.

Everything is ok (in release and debug) if I run the .NET 4.0 application (Ctrl + F5). But when I start debug mode (F5), the program crash when I invoke the C++ method.

The .cpp :

#include "PointEntree.h"
#include <stdio.h>
extern "C" __declspec( dllexport ) int Test1(int a)
{
    printf("coucou\n");
    return 0;
}

The .h:

extern "C" __declspec( dllexport ) int Test1(int);

The .cs :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;

namespace NETProgram
{
static class NativeMethods
{
    [DllImport("kernel32.dll")]
    public static extern IntPtr LoadLibrary(string dllToLoad);

    [DllImport("kernel32.dll")]
    public static extern IntPtr GetProcAddress(IntPtr hModule, string procedureName);

    [DllImport("kernel32.dll")]
    public static extern bool FreeLibrary(IntPtr hModule);
}

class Program
{      
    delegate int Bambou_Test1(int i);

    static void Main(string[] args)
    {
        IntPtr pDll = NativeMethods.LoadLibrary(@"E:\Dev\C#\ImportC++\Bambou\Release\Bambou.dll");
        IntPtr pAddressOfFunctionToCall = NativeMethods.GetProcAddress(pDll, "Test1");

        Bambou_Test1 method = (Bambou_Test1)Marshal.GetDelegateForFunctionPointer(pAddressOfFunctionToCall, typeof(Bambou_Test1));
        method.Invoke(12);
    }
}
}

If I use a classical DLL import like below, it works but it is not what I want to achieve :

[DllImport(@"E:\Dev\C#\ImportC++\Bambou\Debug\Bambou.dll", EntryPoint = "Test1",  CallingConvention=CallingConvention.Cdecl)]
public static extern int Test1(int a);

If someone has any idea, it would be great !

Your `GetProcAddress` based example doesn't specify the calling convention as `Cdecl`. Have you tried adding `[UnmanagedFunctionPointer(CallingConvention.Cdecl)]` to your delegate? — CodesInChaos, Dec 11 '13 at 21:12
It works... thank you very much ! I would never find this trick. — NicoGDF, Dec 11 '13 at 21:20

score 4 · Accepted Answer · answered Dec 11 '13 at 21:26

P/Invoke was mainly designed to interoperate with the Windows API, so in uses the StdCall convention by default. C uses the Cdecl convention by default. You need to change on of the sides to explicitly specify the calling convention so it matches on both sides.

Your classical DLL import specifies the convention with [DllImport(..., CallingConvention=CallingConvention.Cdecl), the variant based on GetDelegateForFunctionPointer does not specify a calling convention (and thus uses StdCall). You need to specify it with [UnmanagedFunctionPointer(CallingConvention.Cdecl)].

Your code is just as wrong without a debugger attached, it just hides the error. Normally such a mismatch would unbalance the stackpointer leading to an instant crash, but the .net marshalling code seems to have special handling for the stackpointer avoiding that crash. Without a debugger is silently swallows the error, with a debugger it displays it.

Crash in debug mode (F5) when calling a native C++ method

1 Answers1