Identify ready2run image

[JensNordenbro]

Hi!

Is there a way of identifying that my app is running using a ready2run compiled version of the code ?

[samsp-msft]

@davidwrighton

[JensNordenbro]

Nobody knows?

[jkotas]

Open the file using System.Reflection.Metadata and check that PEReader.PEHeaders.CorHeader.ManagedNativeHeaderDirectory is non-empty.

[davidwrighton]

This a mostly correct answer. This will indicate whether or not a particular image has ReadyToRun code in it. However, we do not provide an api to determine precisely if the code executing is from that ready to run image. We do not provide this api as the result may vary from run to run, and over time, and the results would be very difficult to use and understand.

[svick]

You can also see this using dotPeek. For example, this is what I see under Metadata → Headers → CLI (Cor20) header for C:\Program Files\dotnet\sdk\3.1.401\Roslyn\bincore\Microsoft.CodeAnalysis.CSharp.dll:

And this is for C:\Users\PetrOnderka\.nuget\packages\microsoft.codeanalysis.csharp\3.7.0\lib\netcoreapp3.1\Microsoft.CodeAnalysis.CSharp.dll:

[JensNordenbro]

Ok @davidwrighton , I take it that you comment says that even though the exe-file has non-empty PEReader.PEHeaders.CorHeader.ManagedNativeHeaderDirectory there are more things that determine if the native image is used or not and there is no deterministic api.

[davidwrighton]

Yes. For instance, we maintain a separate version number for the native code in the native image for cases where we change the ABI of the product and can no longer use the AOT code. In addition, the compiler may not be able to compile specific methods, or a particular method may not be able to be used for various reasons.

[JensNordenbro]

So assume that I do a self contained publish with r2r.
can I then be sure that the ABI cannot be changed and that it is deterministic to look at PEReader.PEHeaders.CorHeader.ManagedNativeHeaderDirectory ?

[AndyAyersMS]

For loaded methods, there is information the assembly and method load events that you can examine to determine:

• did this method come from an R2R compiled assembly?
• was this method compiled via R2R in the assembly?
• was the R2R generated code for this method used at runtime?

You can even do this in process. Here's a partial sample that could be fleshed out to capture all of the above.

[nguyenhoanghai1605]

Yes, you can determine if your app is using a ReadyToRun (R2R) compiled image by analyzing the PE (Portable Executable) headers.

You can do this using the System.Reflection.Metadata API in .NET. Specifically, you can check the ManagedNativeHeaderDirectory in the PE headers.

Here’s a quick code snippet for how to inspect it:

using System.IO;
using System.Reflection.PortableExecutable;
using System.Reflection.Metadata;

using var stream = File.OpenRead("YourAssembly.dll");
using var reader = new PEReader(stream);

var headers = reader.PEHeaders;
if (headers.CorHeader.ManagedNativeHeaderDirectory.Size > 0)
{
    Console.WriteLine("This assembly is ReadyToRun compiled.");
}
else
{
    Console.WriteLine("This assembly is not ReadyToRun compiled.");
}