[Question] Need help obtaining assembly dependencies

[yegor-pelykh]

There is a DLL written in native C++ using CLR Profiling API.
I need to build a dependency tree of all managed assemblies/modules of the process, starting from its main module, using the same native C++, possibly using the same CLR Profiling API or other arsenal of the CLR.
For each assembly/module, I need to know the full path to it.

Something like this approach in C#, but in unmanaged C++.

Dictionary<string, List<string>> GetDependencies(string assemblyPath)
{
    var dependencies = new Dictionary<string, List<string>>();
    var assembly = Assembly.LoadFrom(assemblyPath);
    var referencedAssemblies = assembly.GetReferencedAssemblies();

    dependencies[assembly.FullName] = new List<string> { assembly.Location };
    foreach (var referencedAssembly in referencedAssemblies)
    {
        string referencedAssemblyPath = Path.Combine(Path.GetDirectoryName(assemblyPath), referencedAssembly.Name + ".dll");
        dependencies[assembly.FullName].Add(referencedAssemblyPath);
        var subDependencies = GetDependencies(referencedAssemblyPath);
        foreach (var subDependency in subDependencies)
        {
            if (!dependencies.ContainsKey(subDependency.Key))
            {
                dependencies[subDependency.Key] = subDependency.Value;
            }
        }
    }

    return dependencies;
}

How can this be implemented? Please give me some hints.

Ideally, I need a solution that would work for all versions of .NET/Core/Framework.

For some reason, the profiler callbacks AssemblyLoadStarted / AssemblyLoadFinished are not called for me (given the correct event mask). Therefore, solutions with these methods are unlikely to help.

[jkotas]

the profiler callbacks AssemblyLoadStarted / AssemblyLoadFinished are not called for me (given the correct event mask).

You need to figure out why these are not called for you. These methods are the right mechanism to get the full paths to loaded assemblies.

The assembly loading behavior is controlled by the app code, so you have to wait for the application to load the assembly to get reliable answer.

[yegor-pelykh]

Hi @jkotas, thank you for the answer!

I don't know why, they just aren't called.

My event mask is:

constexpr DWORD eventMask =
    COR_PRF_MONITOR_JIT_COMPILATION |
    COR_PRF_MONITOR_MODULE_LOADS |
    COR_PRF_MONITOR_ASSEMBLY_LOADS |
    COR_PRF_MONITOR_THREADS |
    COR_PRF_MONITOR_CLASS_LOADS |
    COR_PRF_ENABLE_STACK_SNAPSHOT;

return _profilerInfo->SetEventMask(eventMask);

So, I have flag COR_PRF_MONITOR_ASSEMBLY_LOADS set.

What could be the causes?

[jkotas]

Are you able to step through the code in the debugger? Do you see that the SetEventMask is executed and returns success result?

[yegor-pelykh]

Yes. It returns the result S_OK.

[yegor-pelykh]

@jkotas What else could I look at to resolve the issue?

[jkotas]

I cannot think of anything obvious. You may want to spend more time looking at under the debugger.

If you are not able to figure it out, share a complete repro and we can check why it does not work the way you expect.
 
Alternatively, you can study our tests to for COR_PRF_MONITOR_ASSEMBLY_LOADS

runtime/src/tests/profiler/native/moduleload/moduleload.cpp

Line 19 in 39265ca

if (FAILED(hr = pCorProfilerInfo->SetEventMask2(COR_PRF_MONITOR_MODULE_LOADS | COR_PRF_MONITOR_ASSEMBLY_LOADS, 0)))

.

[yegor-pelykh]

@jkotas
You can reproduce this bug (if it's a bug) yourself.

1. There is a repository:
   https://github.com/yegor-pelykh/MixedCallStackSample
   Pull it and build in Visual Studio.

2. Set as a startup project one of these projects: MixedCallStackSample.ClientTest.NetCore or MixedCallStackSample.ClientTest.NetFX (test projects on .NET Core or .NET Framework)

3. Add the flag COR_PRF_MONITOR_ASSEMBLY_LOADS to the method HRESULT CorProfiler::SetEventMask() const.

4. Set breakpoints on methods AssemblyUnloadStarted, AssemblyUnloadFinished, ModuleLoadFinished.

5. Run the program

Methods AssemblyUnloadStarted and AssemblyUnloadFinished are not called.
However, method ModuleLoadFinished will be called.

[jkotas]

Methods AssemblyUnloadStarted and AssemblyUnloadFinished are not called.

I assume that you meant AssemblyLoadStarted and AssemblyLoadFinished. These methods are called, but the debugger does not stop in them. You can add printf("AssemblyLoadStarted\n"); and printf("AssemblyLoadFinished\n"); to these methods to see that they are actually called.

.NET profilers are low-level code. Debugging them using high-level .NET debugger does not work well. The high-level .NET debugger may confuse the .NET profile code with .NET runtime code and skip debugging of the .NET profiler code like it skips .NET runtime.

You need to use unmanaged (C/C++ only) debugger to debug .NET profilers. For example:

• Add the following to the SetEventMask method

        char str[100];
        std::cin.getline(str, 100);

• Start the project by "Start without debugging"
• Use "Attach to process" to attach to the process and set "Code Type" to "Native"
• Now, you can set breakpoints in your profiler. Once you press enter in the app Window, everything will start to run.

Alternatively, you can setup a helper project C++ project with an entrypoint that points to your .exe and debugger type set to native to make this more straightforward.

Yet another option is to use windbg debugger.

[yegor-pelykh]

@jkotas Yes, you are right.
But I can debug most of the other callbacks normally in mixed mode. Why exactly can't I debug these methods normally? How can I make them debuggable in mixed mode, maybe some tricks? I really need this for holistic debugging of this and other code.