Address Resolver

Address Resolver facilitates the deciphering of text-only addresses and call stacks when debugging native C/C++. The tool is especially valuable when debug information is pasted into email and discussions forums in lieu of the sending of program dumps.

Address Resolver determines the valid virtual addresses for text input by loading and reading modules--EXEs, DLLs, and PDBs--whose symbols are referenced by the input. Given a text address, Address Resolver searches loaded modules for a symbol at the address. All virtual addresses in the address input, e.g., a text-only call stack, are thus resolved to symbol.

Access

Open Address Resolver using VAssistX | Debug | Address Resolver. Like all tool windows, Address Resolver can float or be docked.

Loading Modules

To resolve virtual addresses from an EXE or DLL module, load the module's PDB, load the module and let Address Resolver find its PDB, or load the module and work without a PDB. To resolve virtual addresses from multiple modules, e.g., in a complete call stack, load all of the modules that are likely to contain the addresses.

Press 'Add' to locate and load one or more modules.

If you load an EXE or DLL, i.e., not a PDB directly, you have the option of telling Address Resolver to find and load the module's PDB.

Load a PDB directly if:

• you are certain you can identify the PDB associated with the application that generated the virtual addresses, and
• the PDB is moderate in size. (PDBs for large projects can take many minutes to load.)

Load an EXE or DLL module and let Address Resolver find its PDB (by checking 'Use .pdb') if:

• you are not certain which PDB is the correct one, or
• the PDB on located on a symbol server

Load an EXE or DLL module and do not use its PDB if:

• you want to resolve only information exported from the module, or
• the PDB is extremely large and waiting for its load is unnecessarily long. (In this case, resolving is done only to information exported.)

Typically, load only one PDB for each module containing virtual addresses to be resolved. Load multiple PDBs for a module only if you are not certain which build of an EXE or DLL generated your virtual addresses and you want Address Resolver to search in all of the PDBs. When multiple PDBs are loaded, Address Resolver finds only the first symbol at a virtual address. If a found symbol is nonsensical in its context, load fewer or different PDBs, or load them in a different order.

There is no value in loading a PDB directly and then loading its EXE or DLL and asking Address Resolver to load the same PDB via 'Use .pdb'. Load the PDB one way or the other.

Base Addresses

The base address of each loaded module (EXE, DLL, or PDB) must be determined before Address Resolver can map absolute addresses to symbol addresses within the module. Base addresses typically vary with execution. The value specified in Address Resolver must be the value during the execution that generated the virtual addresses. Any other value will prevent Address Resolver from resolving addresses or will cause it to resolve them to incorrect symbols.

There are several ways to obtain the base address of a module:

1. If your module writes its base address to a log, get the base address from the log. (If your module has a log but does not its base address to it, consider the addition for the next debug session.)
2. If your process is still running, use the instance of Visual Studio running Address Resolver to attach to the running process. Select "update base address from debugger" in Address Resolver.
3. If you suspect your module was loaded at its requested base address, select the module in Address Resolve and then "use image base."
   
4. Use trial and error:
   Assume the base address is close but less than the lowest virtual address in your text input.
   Assume the base address is divisible by 0x1000, i.e. 4096.
   Guess a base address and try to resolve a virtual address to a symbol. If no symbols resolve, try a different base address..
   When using trial and error for more than one loaded module, set all unknown base addresses to 0x0 and determine one base address at a time.

Address Formats

Address Resolver can resolve absolute addresses in the following text formats (based on knowing or guessing the base address of the modules per above):

    0x1f348370
    1f348370h
    1f031010

Address Resolver can resolve relative addresses in the following text formats:

    MyApp!MyMethod+0x31cefb
    MyApp.dll!MyMethod+0x31cefb
    MyApp!MyMethod+31aefbh
    MyApp!MyMethod+29aefb
    MyApp.dll!MyMethod+29aefb
    MyApp+0x341010
    MyApp.dll+0x341010

Resolving Symbols

After loading modules and setting base addresses, paste a text version of virtual addresses into the input field and press 'Resolve'. Address Resolver will map the virtual address to symbol names.

Virtual addresses in the input that are not successfully mapped appear as "???" in the resolved output. Virtual addresses fail to resolve for several reasons:

• no or wrong PDB loaded
• an EXE or DLL module is loaded but 'use pdb' is not checked or the pdb cannot be found
• base address(es) are incorrect
• virtual addresses in text input were generated by modules not loaded
• loaded modules are from a build that differs from the build of the text input
• virtual addresses are in an unsupported format

Text in the input field that is assumed not a virtual address is copied as-is to the resolved output.

Address Resolver will not map symbol names to virtual addresses, i.e., you cannot paste into Resolved Output and resolve to the input field.

Symbol Servers

Symbol servers host PDBs for multiple builds of an application. For a loaded module with "use .pdb" checked, Address Resolver locates its PDBs using settings in the instance of Visual Studio that is running Address Resolver. Settings are obtained via:

Visual Studio | Tools | Options | Debugging | Symbols

The correct PDB for the build of the loaded module will be automatically selected using a signature in the loaded module.

Session Management

Load modules, set base addresses, and resolve addresses repeatedly until you have the information you need from Address Resolver. If you are unable to obtain the information you need or anticipate needing to resolve additional virtual addresses for the application, export your session. Import your saved session when you return to debugging of the application.

If you import a session to debug a subsequent build of your application, import your saved session and double check all base addresses.

Begin a new session to clear all loaded modules, address input, and resolved output