Embed .pdb debug symbol information into an .exe file in Visual Studio

Question

I am experimenting an analysis tool that can analyze executable files with embedded debug symbol information in Windows. While trying this tool on several open source projects, I realize that most of the builds do not keep symbolic information in executable files. I am able to compile the source code with VS (2008), but the build normally keeps the debug information in a separated .pdb file, not in the .exe file (unfortunately I only want to read debug information from .exe file and not .pdb file :-().

Does anybody know a way to embed symbol debug information into a single .exe file using Visual Studio?

Iona

Answer 1

I know this is a pretty old issue but this feature has recently been merged into Roslyn: https://github.com/dotnet/roslyn/issues/12390

Maytime

But won't this only be supported by .NET Core? – Flameproof

I don't think so, what makes you say that? This seems like a general compiler feature... – Maytime

Because only CoreCLR seems to be able to understand the embedded PDB? Or am I reading it wrong? – Flameproof

Hmm, Roslyn (used for both .net core and framework) now has support for this, but it's true that the debugger doesn't support it yet for .net framework... I don't know.. – Maytime

Greetings. I come from the distant future of 2023. The world is a dark place: some of us are still required to target .NET Framework 4.8 - however I can report that .NET assemblies and NuGet packages using embedded PDB (i.e. <DebugType>embedded in MSBuild) work perfectly fine and are fully supported on .NET 4.8+ - it was only ever a problem for people stuck on 4.7 but fortunately they're extinct now, phew. – Athletics

Answer 2

The MSDN says that it isn't possible.

It is not possible to create an .exe or .dll that contains debug information. Debug information is always placed in a .pdb file.

Net

While this answer was true when it was posted in 2014, embedded PDBs have been part of the .NET world since 2016. – Athletics

Answer 3

i don't know, yet, how to do it - but there's article on MSDN that talks about it.

A portable executable (i.e .exe or .dll) can have a flag present in the header: (archive)

IMAGE_FILE_DEBUG_STRIPPED

Debugging information was removed and stored separately in stored separately in a .dbg file.

This implies that debugging information can be in the executable, and has the option of being removed and stored in a separate .dbg file.

From MSDN article DBG Files: (archive)

DBG files are portable executable (PE) format files that contain debug information in Codeview format for the Visual Studio debugger (and possibly other formats, depending on how the DBG was created). When you do not have source for certain code, such as libraries or Windows APIs, DBG files permit debugging. DBG files also permit you to do OLE RPC debugging.

DBG files have been superseded by PDB files, which are now more commonly used for debugging.

You can use the REBASE.EXE utility to strip debug information from a PE-format executable and store it in a DBG file. The file characteristic field IMAGE_FILE_DEBUG_STRIPPED in the PE file header tells the debugger that Codeview information has been stripped to a separate DBG file.

A knowledge base article describing the COFF format mentions the dumpbin utility, and it's /SYMBOLS option:

/SYMBOLS      Setting this option causes DUMPBIN to display the COFF symbol
              table. Symbol tables exist in all object files. A COFF symbol
              table appears in an image file only if it is linked with
              /DEBUG /DEBUGTYPE:COFF

The next step, and the part that would answer our question is:

• what format is the embedded debugging information?
• where in the PE is the embedded debugging information stored? (resource?, data section?)

But the answer "it cannot be done" seems to be incorrect.

See also

• IMAGE_FILE_HEADER structure (archive)
• LOADED_IMAGE structure (archive)
• DBG Files (archive)
• Microsoft PE and COFF Specification (archive)
• An In-Depth Look into the Win32 Portable Executable File Format (archive)
• KB121460 - Common Object File Format (COFF) (archive)

Dinnerware

I don't think it's possible in the .Net framework, though. Older C++ compilers seemed to have ways of embedding it, yes, though these ways, and the information in it, varied widely based on the compiler and the targeted debugger. – Aeon

Ian, did you ever figure this out for C++? – Vigue

@Mehrdad I never figured it out at all! – Dinnerware

Answer 4

There is no built-in support in Visual Studio for this type of operation (at least for managed languages). The .PDB and .EXE files are created at the same time and have no option for embedding. I'm not even sure the .EXE format supports embedding PDB symbols although I could be wrong on this point.

The only course I can see is embedding the PDB as a resource in th e .EXE. However that would have to be a post build step since the two are built at the same time. And there is the potential for invalidating parts of the PDB if you modify the EXE after it's been built.

Is there a particular reason you're trying to do this? I'm imagining it's going to end up causing you a lot of pain as 1) it's not supported AFAIK and 2) the tool chain is geared towards looking for PDB in the same directory not within the .EXE. Deploying 2 files is a bit annoying at first but it's how its done at this point.

Righthand

The question makes no mention of managed labguages. Use compiler option /Z7 to embed debug information in the library. – Manizales

Answer 5

I'm pretty sure PDBs were always stand-alone files. VC++ used to have a switch that would cause it to emit (limited compared to PDB) symbol information to a "CodeView" .DBG file that by default was embedded in the EXE. However, that switch appears to no longer be supported in the newer (post 6.x ?) versions of the compiler.

Disable