[NativeSession] Implement NativeSession::findSymbolByAddress.

[akhuang]

Summary

This implements searching for function symbols and public symbols by address.

More specifically,
-Implements NativeSession::findSymbolByAddress for function symbols and public symbols. I think data symbols are also searched for, but that isn't implemented here.
-Adds classes for NativeFunctionSymbol and NativePublicSymbol
-Adds a '-use-native-pdb-reader' option to llvm-symbolizer, for testing

[akhuang]

clean up

[akhuang]

Fix some things, update description

[labath]

llvm/lib/DebugInfo/PDB/Native/SymbolCache.cpp

425

IntervalMap explodes if you try to insert overlapping intervals into it. How sure are you that no input will contain overlapping addresses?

I'm not sure what's the pdb position on asserting on invalid inputs, but it certainly seems like this could happen with a hand-crafted/corrupted pdbs. However, I wouldn't be surprised if that happens for "valid" pdbs too...

[amccarth]

llvm/include/llvm/DebugInfo/PDB/Native/SymbolCache.h

93

In the NativeSession, we have findSymbolByAddress, -ByRVA, and -BySectOffset. Here we find -ByAddress, but is seems like it should be -BySectOffset.

I realized you inherited a bunch of the API definition, but is there a technical reason for the naming inconsistency? Can we make it more consistent without breaking things?

llvm/lib/DebugInfo/PDB/Native/NativeFunctionSymbol.cpp

22

The reason for the std::move is not obvious (to me). The constructor takes the Sym parameter by value (so it's a copy) and then stashes it in member Sym. Is the goal to avoid a second copy from the argument to the member?

If it's expensive to copy, should the constructor take a const & and then copy the value (once) into the data member?

(And if you must use std::move, I think this file should include <utility>.)

llvm/lib/DebugInfo/PDB/Native/SymbolCache.cpp

310

this } would make more sense just above default:

425

Can you clarify "IntervalMap explodes"? Crashes, hangs, uses crazy amounts of memory or time, corrupts itself?

From the IntervalMap comments:

/// insert - Add a mapping of [a;b] to y, coalesce with adjacent intervals.
/// It is assumed that no key in the interval is mapped to another value, but
/// overlapping intervals already mapped to y will be coalesced.

If I understand that correctly, it's not overlapping intervals in general, but ones that give a different value for at least part of the overlap. Perhaps IntervalMap needs a way to test for a conflicting overlap.

[akhuang]

llvm/lib/DebugInfo/PDB/Native/SymbolCache.cpp

425

Would it be reasonable to just check for overlap before adding to the map and ignore those?

Also, I hadn't run this on larger pdbs before but it seems like the IntervalMap sometimes segfaults on destruction (in map.visitNodes()).

[labath]

llvm/lib/DebugInfo/PDB/Native/NativeFunctionSymbol.cpp

22

This is actually the recommended way to pass objects if your function "consumes" them and you don't care about every last drop of performance. The assertion that this will always incur a copy is not true. In fact, const T & guarantees a copy. This puts the choice into the hands of the caller. If the caller calls the constructor with an lvalue, there will be 1 copy (+ 1 move). If the caller calls this with an xvalue, there will be no copies (only two moves).

llvm/lib/DebugInfo/PDB/Native/SymbolCache.cpp

425

explodes == assert if you have asserts enabled, UB otherwise

You're right that this only happens if the mapped-to value differs. I didn't mention that part, but I assume this is going to be hold if we actually end up with overlapping contribution (i.e., C.Imod is some sort of a contribution identifier). IntervalMap does have a method for testing overlaps (it's called overlaps).

As for checking for overlap, I think that is definitely better than crashing. Whether that is the "reasonable" thing to do depends on the use case, which I don't know anything about.

BTW: Instead passing End-1 you could consider instantiating the IntervalMap to use half-open intervals.

[amccarth]

llvm/lib/DebugInfo/PDB/Native/NativeFunctionSymbol.cpp

22

Two moves would require that Sym has a move constructor, right? It looks like Sym is a codeview::ProcSym. I suppose it might get a compiler-generated move constructor, but that class appears to be a collection of scalar types (enums, integers, and a non-owning raw pointer).

[rnk]

Cool. :)

llvm/lib/DebugInfo/PDB/Native/SymbolCache.cpp

339

This is a VarStreamArray. I think you can skip past entire procedure regions by doing something like this:

CVSymbolArray Syms = ModS.getSymbolArray();
for (auto I = Syms.begin(), E = Syms.end(); I != E; ++I) {
  ...
  // If this is not the procsym you want
  I = Syms.at(PS.Next);
}

Something like that, maybe.

343

We discussed adjusting this condition to be a range check.

[akhuang]

Address comments
-check for overlap before inserting into IntervalMap and just ignore any overlapping sections
-change function names from -ByAddress to -BySectOffset

I also fixed a few other things
-changed public symbol search to search by upper bound instead of exact match
-function symbol search now searches within the address range (offset+codesize), instead
of just the starting address

[labath]

llvm/lib/DebugInfo/PDB/Native/NativeFunctionSymbol.cpp

22

Ah, right, sorry. In that case a const T&would be more suitable.

[akhuang]

-implement skipping to the end of symbols while searching
-remove std::move in pdb symbol constructors

[akhuang]

change constructor to take a const & to SymbolRecord

[akhuang]

llvm/include/llvm/DebugInfo/PDB/Native/SymbolCache.h

93

Yep, it can definitely be -BySectOffset here.

llvm/lib/DebugInfo/PDB/Native/NativeFunctionSymbol.cpp

22

thanks; I think the std::move was just there because it was in the class I copied this from, but I've changed the constructor to take a const &

llvm/lib/DebugInfo/PDB/Native/SymbolCache.cpp

343

I think I had just updated the patch to include this.

[akhuang]

clean up

[akhuang]

ping! I think I've addressed all the comments here

[amccarth]

Looks good. Thanks for the improvements.

I saw one more opportunity to clarify -FromSectOffset rather than -FromAddress for a couple methods, just in case you want to address those before you land this.

llvm/include/llvm/DebugInfo/PDB/Native/NativeSession.h

112

Another -FromAddress versus -FromSectOffset.

[morehouse]

It looks like this patch added a bunch of undefined symbols to the sanitizer symbolizer, and is causing the buildbot to fail:

http://lab.llvm.org:8011/builders/sanitizer-x86_64-linux/builds/27269/steps/build%2032-bit%20symbolizer%20for%20compiler_rt_build/logs/stdio

+ cd /b/sanitizer-x86_64-linux/build/symbolizer_build32/symbolizer
+ rm -rf /b/sanitizer-x86_64-linux/build/symbolizer_build32/symbolizer/symbolizer
+ mkdir /b/sanitizer-x86_64-linux/build/symbolizer_build32/symbolizer/symbolizer
+ cd /b/sanitizer-x86_64-linux/build/symbolizer_build32/symbolizer/symbolizer
+ echo Compiling...
+ SYMBOLIZER_FLAGS='-m32 -fPIC -flto -Os -g0 -DNDEBUG -fno-rtti -fno-exceptions -nostdinc++ -I/b/sanitizer-x86_64-linux/build/symbolizer_build32/symbolizer/zlib -I/b/sanitizer-x86_64-linux/build/symbolizer_build32/symbolizer/libcxx/include/c++/v1 -I/b/sanitizer-x86_64-linux/build/llvm-project/llvm/include -I/b/sanitizer-x86_64-linux/build/symbolizer_build32/symbolizer/llvm/include -std=c++14'
+ /b/sanitizer-x86_64-linux/build/llvm_build64/bin/clang++ -m32 -fPIC -flto -Os -g0 -DNDEBUG -fno-rtti -fno-exceptions -nostdinc++ -I/b/sanitizer-x86_64-linux/build/symbolizer_build32/symbolizer/zlib -I/b/sanitizer-x86_64-linux/build/symbolizer_build32/symbolizer/libcxx/include/c++/v1 -I/b/sanitizer-x86_64-linux/build/llvm-project/llvm/include -I/b/sanitizer-x86_64-linux/build/symbolizer_build32/symbolizer/llvm/include -std=c++14 /b/sanitizer-x86_64-linux/build/llvm-project/compiler-rt/lib/sanitizer_common/symbolizer/sanitizer_symbolize.cpp /b/sanitizer-x86_64-linux/build/llvm-project/compiler-rt/lib/sanitizer_common/symbolizer/sanitizer_wrappers.cpp -c
Compiling...
+ /b/sanitizer-x86_64-linux/build/llvm_build64/bin/llvm-ar rc symbolizer.a sanitizer_symbolize.o sanitizer_wrappers.o
+ SYMBOLIZER_API_LIST=__sanitizer_symbolize_code,__sanitizer_symbolize_data,__sanitizer_symbolize_flush,__sanitizer_symbolize_demangle
+ /b/sanitizer-x86_64-linux/build/llvm-project/compiler-rt/lib/sanitizer_common/symbolizer/scripts/ar_to_bc.sh /b/sanitizer-x86_64-linux/build/symbolizer_build32/symbolizer/libcxx/lib/libc++.a /b/sanitizer-x86_64-linux/build/symbolizer_build32/symbolizer/libcxx/lib/libc++abi.a /b/sanitizer-x86_64-linux/build/symbolizer_build32/symbolizer/llvm/lib/libLLVMSymbolize.a /b/sanitizer-x86_64-linux/build/symbolizer_build32/symbolizer/llvm/lib/libLLVMObject.a /b/sanitizer-x86_64-linux/build/symbolizer_build32/symbolizer/llvm/lib/libLLVMBinaryFormat.a /b/sanitizer-x86_64-linux/build/symbolizer_build32/symbolizer/llvm/lib/libLLVMDebugInfoDWARF.a /b/sanitizer-x86_64-linux/build/symbolizer_build32/symbolizer/llvm/lib/libLLVMSupport.a /b/sanitizer-x86_64-linux/build/symbolizer_build32/symbolizer/llvm/lib/libLLVMDebugInfoPDB.a /b/sanitizer-x86_64-linux/build/symbolizer_build32/symbolizer/llvm/lib/libLLVMDemangle.a /b/sanitizer-x86_64-linux/build/symbolizer_build32/symbolizer/llvm/lib/libLLVMMC.a /b/sanitizer-x86_64-linux/build/symbolizer_build32/symbolizer/llvm/lib/libLLVMTextAPI.a /b/sanitizer-x86_64-linux/build/symbolizer_build32/symbolizer/zlib/libz.a symbolizer.a all.bc
Inputs: /b/sanitizer-x86_64-linux/build/symbolizer_build32/symbolizer/libcxx/lib/libc++.a /b/sanitizer-x86_64-linux/build/symbolizer_build32/symbolizer/libcxx/lib/libc++abi.a /b/sanitizer-x86_64-linux/build/symbolizer_build32/symbolizer/llvm/lib/libLLVMSymbolize.a /b/sanitizer-x86_64-linux/build/symbolizer_build32/symbolizer/llvm/lib/libLLVMObject.a /b/sanitizer-x86_64-linux/build/symbolizer_build32/symbolizer/llvm/lib/libLLVMBinaryFormat.a /b/sanitizer-x86_64-linux/build/symbolizer_build32/symbolizer/llvm/lib/libLLVMDebugInfoDWARF.a /b/sanitizer-x86_64-linux/build/symbolizer_build32/symbolizer/llvm/lib/libLLVMSupport.a /b/sanitizer-x86_64-linux/build/symbolizer_build32/symbolizer/llvm/lib/libLLVMDebugInfoPDB.a /b/sanitizer-x86_64-linux/build/symbolizer_build32/symbolizer/llvm/lib/libLLVMDemangle.a /b/sanitizer-x86_64-linux/build/symbolizer_build32/symbolizer/llvm/lib/libLLVMMC.a /b/sanitizer-x86_64-linux/build/symbolizer_build32/symbolizer/llvm/lib/libLLVMTextAPI.a /b/sanitizer-x86_64-linux/build/symbolizer_build32/symbolizer/zlib/libz.a /b/sanitizer-x86_64-linux/build/symbolizer_build32/symbolizer/symbolizer/symbolizer.a
Output: /b/sanitizer-x86_64-linux/build/symbolizer_build32/symbolizer/symbolizer/all.bc
/tmp/tmp.ffguFzwEJO /b/sanitizer-x86_64-linux/build/symbolizer_build32/symbolizer/symbolizer
+ echo Optimizing...
+ /b/sanitizer-x86_64-linux/build/llvm_build64/bin/opt -internalize -internalize-public-api-list=__sanitizer_symbolize_code,__sanitizer_symbolize_data,__sanitizer_symbolize_flush,__sanitizer_symbolize_demangle all.bc -o opt.bc
Optimizing...
+ /b/sanitizer-x86_64-linux/build/llvm_build64/bin/clang -m32 -fPIC -flto -Os -g0 -DNDEBUG -fno-rtti -fno-exceptions -fno-lto -c opt.bc -o symbolizer.o
+ echo 'Checking undefined symbols...'
Checking undefined symbols...
+ nm -f posix -g symbolizer.o
+ cut -f 1,2 -d ' '
+ LC_COLLATE=C
+ sort -u
+ diff -u /b/sanitizer-x86_64-linux/build/llvm-project/compiler-rt/lib/sanitizer_common/symbolizer/scripts/global_symbols.txt undefined.new
+ grep -E '^\+[^+]'
+_ZN4llvm3msf17MappedBlockStream15createFpmStreamERKNS0_9MSFLayoutENS_15BinaryStreamRefERNS_20BumpPtrAllocatorImplINS_15MallocAllocatorELj4096ELj4096ELj128EEE U
+_ZN4llvm3msf17MappedBlockStream19createIndexedStreamERKNS0_9MSFLayoutENS_15BinaryStreamRefEjRNS_20BumpPtrAllocatorImplINS_15MallocAllocatorELj4096ELj4096ELj128EEE U
+_ZN4llvm3msf17MappedBlockStream21createDirectoryStreamERKNS0_9MSFLayoutENS_15BinaryStreamRefERNS_20BumpPtrAllocatorImplINS_15MallocAllocatorELj4096ELj4096ELj128EEE U
+_ZN4llvm3msf18validateSuperBlockERKNS0_10SuperBlockE U
+_ZN4llvm8codeview13CodeViewError2IDE U
+_ZN4llvm8codeview15CVErrorCategoryEv U
+_ZN4llvm8codeview15getModifiedTypeERKNS0_8CVRecordINS0_12TypeLeafKindEEE U
+_ZN4llvm8codeview15isUdtForwardRefENS0_8CVRecordINS0_12TypeLeafKindEEE U
+_ZN4llvm8codeview17TypeRecordMapping12visitTypeEndERNS0_8CVRecordINS0_12TypeLeafKindEEE U
+_ZN4llvm8codeview17TypeRecordMapping14visitTypeBeginERNS0_8CVRecordINS0_12TypeLeafKindEEE U
+_ZN4llvm8codeview17TypeRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_12TypeLeafKindEEERNS0_10EnumRecordE U
+_ZN4llvm8codeview17TypeRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_12TypeLeafKindEEERNS0_11ArrayRecordE U
+_ZN4llvm8codeview17TypeRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_12TypeLeafKindEEERNS0_11ClassRecordE U
+_ZN4llvm8codeview17TypeRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_12TypeLeafKindEEERNS0_11UnionRecordE U
+_ZN4llvm8codeview17TypeRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_12TypeLeafKindEEERNS0_13ArgListRecordE U
+_ZN4llvm8codeview17TypeRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_12TypeLeafKindEEERNS0_13PointerRecordE U
+_ZN4llvm8codeview17TypeRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_12TypeLeafKindEEERNS0_14ModifierRecordE U
+_ZN4llvm8codeview17TypeRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_12TypeLeafKindEEERNS0_15ProcedureRecordE U
+_ZN4llvm8codeview17TypeRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_12TypeLeafKindEEERNS0_18VFTableShapeRecordE U
+_ZN4llvm8codeview17TypeRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_12TypeLeafKindEEERNS0_20MemberFunctionRecordE U
+_ZN4llvm8codeview18DebugSubsectionRefD2Ev U
+_ZN4llvm8codeview19SymbolRecordMapping14visitSymbolEndERNS0_8CVRecordINS0_10SymbolKindEEE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_10ObjNameSymE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_10ProcRefSymE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_10SectionSymE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_10Thunk32SymE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_11Compile2SymE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_11Compile3SymE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_11ConstantSymE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_11DefRangeSymE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_11EnvBlockSymE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_11PublicSym32E U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_11RegisterSymE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_11ScopeEndSymE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_12BuildInfoSymE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_12CoffGroupSymE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_12FrameProcSymE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_13AnnotationSymE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_13BPRelativeSymE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_13FileStaticSymE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_13InlineSiteSymE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_13TrampolineSymE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_14FrameCookieSymE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_14RegRelativeSymE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_15CallSiteInfoSymE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_17UsingNamespaceSymE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_18ThreadLocalDataSymE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_19DefRangeRegisterSymE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_19DefRangeSubfieldSymE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_21HeapAllocationSiteSymE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_22DefRangeRegisterRelSymE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_26DefRangeFramePointerRelSymE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_27DefRangeSubfieldRegisterSymE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_35DefRangeFramePointerRelFullScopeSymE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_6UDTSymE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_7DataSymE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_7ProcSymE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_8BlockSymE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_8LabelSymE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_8LocalSymE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_9CallerSymE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitKnownRecordERNS0_8CVRecordINS0_10SymbolKindEEERNS0_9ExportSymE U
+_ZN4llvm8codeview19SymbolRecordMapping16visitSymbolBeginERNS0_8CVRecordINS0_10SymbolKindEEE U
+_ZN4llvm8codeview20readSymbolFromStreamENS_15BinaryStreamRefEj U
+_ZN4llvm8codeview23visitMemberRecordStreamENS_8ArrayRefIhEERNS0_20TypeVisitorCallbacksE U
+_ZN4llvm8codeview24LazyRandomTypeCollectionC1ERKNS_14VarStreamArrayINS0_8CVRecordINS0_12TypeLeafKindEEENS_23VarStreamArrayExtractorIS5_EEEEjNS_16FixedStreamArrayINS0_15TypeIndexOffsetEEE U
+_ZN4llvm8codeview27DebugFrameDataSubsectionRef10initializeENS_15BinaryStreamRefE U
+_ZN4llvm8codeview29DebugStringTableSubsectionRef10initializeENS_15BinaryStreamRefE U
+_ZN4llvm8codeview29DebugStringTableSubsectionRefC1Ev U
+_ZNK4llvm8codeview29DebugStringTableSubsectionRef9getStringEj U
+_ZTVN4llvm8codeview17TypeRecordMappingE U
+_ZTVN4llvm8codeview19SymbolRecordMappingE U
+__isinf U
+ echo 'Failed: unexpected symbols'
+ exit 1
Failed: unexpected symbols

Could you please take a look?

[akhuang]

I'll look into it, thanks for letting me know!

[akhuang]

@morehouse Do you happen to know what would cause undefined symbols to be added? I reproduced it and it seems like it started from implementing loadDataForEXE (in https://reviews.llvm.org/D78128)

[morehouse]

In D79269#2045451, @akhuang wrote:

@morehouse Do you happen to know what would cause undefined symbols to be added? I reproduced it and it seems like it started from implementing loadDataForEXE (in https://reviews.llvm.org/D78128)

Does either patch introduce new dependencies for the symbolizer? Maybe we need to add another library here.

[akhuang]

Looks like it also needs libLLVMDebugInfoCodeView.a and libLLVMDebugInfoMSF.a; I just added them to the script.

[rnk]

I would like to register a small complaint that this script even exists in the first place. LLVM uses CMake. It's not OK for contributors to add their own ad-hoc shell script build systems and then impose the costs of maintaining them on other contributors. However, on the other hand, I understand what this script is trying to do, and do not have concrete suggestions on how to replace it. My only request is that the team that maintains it remains proactive about finding and fixing these problems.

llvm/include/llvm/DebugInfo/PDB/DIA/DIASession.h

public:
   std::unique_ptr<PDBSymbolExe> getGlobalScope() override;
   std::unique_ptr<PDBSymbol> getSymbolById(SymIndexId SymbolId) const override;
 
   bool addressForVA(uint64_t VA, uint32_t &Section,
                     uint32_t &Offset) const override;
   bool addressForRVA(uint32_t RVA, uint32_t &Section,
                      uint32_t &Offset) const override;
 
-  std::unique_ptr<PDBSymbol>
-  findSymbolByAddress(uint64_t Address, PDB_SymType Type) const override;
+  std::unique_ptr<PDBSymbol> findSymbolByAddress(uint64_t Address,
+                                                 PDB_SymType Type) override;
   std::unique_ptr<PDBSymbol> findSymbolByRVA(uint32_t RVA,
-                                             PDB_SymType Type) const override;
-  std::unique_ptr<PDBSymbol>
-  findSymbolBySectOffset(uint32_t Section, uint32_t Offset,
-                         PDB_SymType Type) const override;
+                                             PDB_SymType Type) override;
+  std::unique_ptr<PDBSymbol> findSymbolBySectOffset(uint32_t Section,
+                                                    uint32_t Offset,
+                                                    PDB_SymType Type) override;
 
   std::unique_ptr<IPDBEnumLineNumbers>
   findLineNumbers(const PDBSymbolCompiland &Compiland,
                   const IPDBSourceFile &File) const override;
   std::unique_ptr<IPDBEnumLineNumbers>
   findLineNumbersByAddress(uint64_t Address, uint32_t Length) const override;
   std::unique_ptr<IPDBEnumLineNumbers>
   findLineNumbersByRVA(uint32_t RVA, uint32_t Length) const override;

llvm/include/llvm/DebugInfo/PDB/IPDBSession.h

public:
   virtual bool addressForRVA(uint32_t RVA, uint32_t &Section,
                              uint32_t &Offset) const = 0;
 
   template <typename T>
   std::unique_ptr<T> getConcreteSymbolById(SymIndexId SymbolId) const {
     return unique_dyn_cast_or_null<T>(getSymbolById(SymbolId));
   }
 
+  virtual std::unique_ptr<PDBSymbol> findSymbolByAddress(uint64_t Address,
+                                                         PDB_SymType Type) = 0;
+  virtual std::unique_ptr<PDBSymbol> findSymbolByRVA(uint32_t RVA,
+                                                     PDB_SymType Type) = 0;
   virtual std::unique_ptr<PDBSymbol>
-  findSymbolByAddress(uint64_t Address, PDB_SymType Type) const = 0;
-  virtual std::unique_ptr<PDBSymbol>
-  findSymbolByRVA(uint32_t RVA, PDB_SymType Type) const = 0;
-  virtual std::unique_ptr<PDBSymbol>
-  findSymbolBySectOffset(uint32_t Sect, uint32_t Offset,
-                         PDB_SymType Type) const = 0;
+  findSymbolBySectOffset(uint32_t Sect, uint32_t Offset, PDB_SymType Type) = 0;
 
   virtual std::unique_ptr<IPDBEnumLineNumbers>
   findLineNumbers(const PDBSymbolCompiland &Compiland,
                   const IPDBSourceFile &File) const = 0;
   virtual std::unique_ptr<IPDBEnumLineNumbers>
   findLineNumbersByAddress(uint64_t Address, uint32_t Length) const = 0;
   virtual std::unique_ptr<IPDBEnumLineNumbers>
   findLineNumbersByRVA(uint32_t RVA, uint32_t Length) const = 0;

llvm/include/llvm/DebugInfo/PDB/Native/NativeFunctionSymbol.h

+//===- NativeFunctionSymbol.h - info about function symbols -----*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_PDB_NATIVE_NATIVEFUNCTIONSYMBOL_H
+#define LLVM_DEBUGINFO_PDB_NATIVE_NATIVEFUNCTIONSYMBOL_H
+
+#include "llvm/DebugInfo/CodeView/CodeView.h"
+#include "llvm/DebugInfo/CodeView/SymbolRecord.h"
+#include "llvm/DebugInfo/PDB/Native/NativeRawSymbol.h"
+#include "llvm/DebugInfo/PDB/Native/NativeSession.h"
+
+namespace llvm {
+namespace pdb {
+
+class NativeFunctionSymbol : public NativeRawSymbol {
+public:
+  NativeFunctionSymbol(NativeSession &Session, SymIndexId Id,
+                       codeview::ProcSym Sym);
+
+  ~NativeFunctionSymbol() override;
+
+  void dump(raw_ostream &OS, int Indent, PdbSymbolIdField ShowIdFields,
+            PdbSymbolIdField RecurseIdFields) const override;
+
+  uint32_t getAddressOffset() const override;
+  uint32_t getAddressSection() const override;
+  std::string getName() const override;
+  PDB_SymType getSymTag() const override;
+  uint64_t getLength() const override;
+  uint32_t getRelativeVirtualAddress() const override;
+  uint64_t getVirtualAddress() const override;
+
+protected:
+  codeview::ProcSym Sym;
+};
+
+} // namespace pdb
+} // namespace llvm
+
+#endif // LLVM_DEBUGINFO_PDB_NATIVE_NATIVEFUNCTIONSYMBOL_H

llvm/include/llvm/DebugInfo/PDB/Native/NativePublicSymbol.h

+//===- NativePublicSymbol.h - info about public symbols ---------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_PDB_NATIVE_NATIVEPUBLICSYMBOL_H
+#define LLVM_DEBUGINFO_PDB_NATIVE_NATIVEPUBLICSYMBOL_H
+
+#include "llvm/DebugInfo/CodeView/CodeView.h"
+#include "llvm/DebugInfo/CodeView/SymbolRecord.h"
+#include "llvm/DebugInfo/PDB/Native/NativeRawSymbol.h"
+#include "llvm/DebugInfo/PDB/Native/NativeSession.h"
+
+namespace llvm {
+namespace pdb {
+
+class NativePublicSymbol : public NativeRawSymbol {
+public:
+  NativePublicSymbol(NativeSession &Session, SymIndexId Id,
+                     codeview::PublicSym32 Sym);
+
+  ~NativePublicSymbol() override;
+
+  void dump(raw_ostream &OS, int Indent, PdbSymbolIdField ShowIdFields,
+            PdbSymbolIdField RecurseIdFields) const override;
+
+  uint32_t getAddressOffset() const override;
+  uint32_t getAddressSection() const override;
+  std::string getName() const override;
+  PDB_SymType getSymTag() const override;
+  uint32_t getRelativeVirtualAddress() const override;
+  uint64_t getVirtualAddress() const override;
+
+protected:
+  codeview::PublicSym32 Sym;
+};
+
+} // namespace pdb
+} // namespace llvm
+
+#endif // LLVM_DEBUGINFO_PDB_NATIVE_NATIVEPUBLICSYMBOL_H

llvm/include/llvm/DebugInfo/PDB/Native/NativeSession.h

public:
   std::unique_ptr<PDBSymbolExe> getGlobalScope() override;
   std::unique_ptr<PDBSymbol> getSymbolById(SymIndexId SymbolId) const override;
 
   bool addressForVA(uint64_t VA, uint32_t &Section,
                     uint32_t &Offset) const override;
   bool addressForRVA(uint32_t RVA, uint32_t &Section,
                      uint32_t &Offset) const override;
 
-  std::unique_ptr<PDBSymbol>
-  findSymbolByAddress(uint64_t Address, PDB_SymType Type) const override;
+  std::unique_ptr<PDBSymbol> findSymbolByAddress(uint64_t Address,
+                                                 PDB_SymType Type) override;
   std::unique_ptr<PDBSymbol> findSymbolByRVA(uint32_t RVA,
-                                             PDB_SymType Type) const override;
-  std::unique_ptr<PDBSymbol>
-  findSymbolBySectOffset(uint32_t Sect, uint32_t Offset,
-                         PDB_SymType Type) const override;
+                                             PDB_SymType Type) override;
+  std::unique_ptr<PDBSymbol> findSymbolBySectOffset(uint32_t Sect,
+                                                    uint32_t Offset,
+                                                    PDB_SymType Type) override;
 
   std::unique_ptr<IPDBEnumLineNumbers>
   findLineNumbers(const PDBSymbolCompiland &Compiland,
                   const IPDBSourceFile &File) const override;
   std::unique_ptr<IPDBEnumLineNumbers>
   findLineNumbersByAddress(uint64_t Address, uint32_t Length) const override;
   std::unique_ptr<IPDBEnumLineNumbers>
   findLineNumbersByRVA(uint32_t RVA, uint32_t Length) const override;
public:
   std::unique_ptr<IPDBEnumFrameData> getFrameData() const override;
 
   PDBFile &getPDBFile() { return *Pdb; }
   const PDBFile &getPDBFile() const { return *Pdb; }
 
   NativeExeSymbol &getNativeGlobalScope() const;
   SymbolCache &getSymbolCache() { return Cache; }
   const SymbolCache &getSymbolCache() const { return Cache; }
+  uint32_t getRVAFromAddress(uint32_t Section, uint32_t Offset) const;
+  uint64_t getVAFromAddress(uint32_t Section, uint32_t Offset) const;
 
 private:
   void initializeExeSymbol();
 
   std::unique_ptr<PDBFile> Pdb;
   std::unique_ptr<BumpPtrAllocator> Allocator;
 
   SymbolCache Cache;
   SymIndexId ExeSymbol = 0;
   uint64_t LoadAddress = 0;
 };
 } // namespace pdb
 } // namespace llvm
 
 #endif

llvm/include/llvm/DebugInfo/PDB/Native/SymbolCache.h

 //==- SymbolCache.h - Cache of native symbols and ids ------------*- C++ -*-==//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_PDB_NATIVE_SYMBOLCACHE_H
 #define LLVM_DEBUGINFO_PDB_NATIVE_SYMBOLCACHE_H
 
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/IntervalMap.h"
+#include "llvm/DebugInfo/CodeView/SymbolRecord.h"
 #include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
 #include "llvm/DebugInfo/PDB/Native/NativeRawSymbol.h"
 
 #include <memory>
 #include <vector>
 
class SymbolCache {
 
   /// List of SymIndexIds for each compiland, indexed by compiland index as they
   /// appear in the PDB file.
   std::vector<SymIndexId> Compilands;
 
   /// Map from global symbol offset to SymIndexId.
   DenseMap<uint32_t, SymIndexId> GlobalOffsetToSymbolId;
 
+  /// Map from segment and code offset to SymIndexId.
+  DenseMap<std::pair<uint32_t, uint32_t>, SymIndexId> AddressToFunctionSymId;
+  DenseMap<std::pair<uint32_t, uint32_t>, SymIndexId> AddressToPublicSymId;
+
+  /// Map from virtual address to module index.
+  IntervalMap<uint32_t, uint16_t> AddrToModuleIndex;
+  IntervalMap<uint32_t, uint32_t>::Allocator IMapAllocator;
+
   SymIndexId createSymbolPlaceholder() {
     SymIndexId Id = Cache.size();
     Cache.push_back(nullptr);
     return Id;
   }
 
   template <typename ConcreteSymbolT, typename CVRecordT, typename... Args>
   SymIndexId createSymbolForType(codeview::TypeIndex TI, codeview::CVType CVT,
class SymbolCache {
   }
 
   SymIndexId createSymbolForModifiedType(codeview::TypeIndex ModifierTI,
                                          codeview::CVType CVT);
 
   SymIndexId createSimpleType(codeview::TypeIndex TI,
                               codeview::ModifierOptions Mods);
 
+  std::unique_ptr<PDBSymbol> findFunctionSymbolByAddress(uint32_t Sect,
+                                                         uint32_t Offset);
+  std::unique_ptr<PDBSymbol> findPublicSymbolByAddress(uint32_t Sect,
+                                                       uint32_t Offset);
+
+  void parseSectionContribs();
+  Optional<uint16_t> getModuleIndexForAddr(uint32_t Sect,
+                                           uint32_t Offset) const;
+
 public:
   SymbolCache(NativeSession &Session, DbiStream *Dbi);
 
   template <typename ConcreteSymbolT, typename... Args>
   SymIndexId createSymbol(Args &&... ConstructorArgs) {
     SymIndexId Id = Cache.size();
 
     // Initial construction must not access the cache, since it must be done
if (Result.second)
           createSymbol<ConcreteSymbolT>(std::forward<Args>(ConstructorArgs)...);
     else
       SymId = Result.first->second;
     return SymId;
   }
 
   SymIndexId getOrCreateGlobalSymbolByOffset(uint32_t Offset);
 
+  std::unique_ptr<PDBSymbol> findSymbolByAddress(uint32_t Sect, uint32_t Offset,
+                                                 PDB_SymType Type);
+
   std::unique_ptr<PDBSymbolCompiland> getOrCreateCompiland(uint32_t Index);
   uint32_t getNumCompilands() const;
 
   std::unique_ptr<PDBSymbol> getSymbolById(SymIndexId SymbolId) const;
 
   NativeRawSymbol &getNativeSymbolById(SymIndexId SymbolId) const;
 
   template <typename ConcreteT>

llvm/include/llvm/DebugInfo/Symbolize/Symbolize.h

 public:
   struct Options {
     FunctionNameKind PrintFunctions = FunctionNameKind::LinkageName;
     FileLineInfoKind PathStyle = FileLineInfoKind::AbsoluteFilePath;
     bool UseSymbolTable = true;
     bool Demangle = true;
     bool RelativeAddresses = false;
     bool UntagAddresses = false;
+    bool UseNativePDBReader = false;
     std::string DefaultArch;
     std::vector<std::string> DsymHints;
     std::string FallbackDebugPath;
     std::string DWPName;
     std::vector<std::string> DebugFileDirectory;
   };
 
   LLVMSymbolizer() = default;

llvm/lib/DebugInfo/PDB/CMakeLists.txt

add_pdb_impl_folder(Native
   Native/InjectedSourceStream.cpp
   Native/ModuleDebugStream.cpp
   Native/NativeCompilandSymbol.cpp
   Native/NativeEnumGlobals.cpp
   Native/NativeEnumInjectedSources.cpp
   Native/NativeEnumModules.cpp
   Native/NativeEnumTypes.cpp
   Native/NativeExeSymbol.cpp
+  Native/NativeFunctionSymbol.cpp
+  Native/NativePublicSymbol.cpp
   Native/NativeRawSymbol.cpp
   Native/NativeSymbolEnumerator.cpp
   Native/NativeTypeArray.cpp
   Native/NativeTypeBuiltin.cpp
   Native/NativeTypeEnum.cpp
   Native/NativeTypeFunctionSig.cpp
   Native/NativeTypePointer.cpp
   Native/NativeTypeTypedef.cpp

llvm/lib/DebugInfo/PDB/DIA/DIASession.cpp

DIASession::getSymbolById(SymIndexId SymbolId) const {
   CComPtr<IDiaSymbol> LocatedSymbol;
   if (S_OK != Session->symbolById(SymbolId, &LocatedSymbol))
     return nullptr;
 
   auto RawSymbol = std::make_unique<DIARawSymbol>(*this, LocatedSymbol);
   return PDBSymbol::create(*this, std::move(RawSymbol));
 }
 
-std::unique_ptr<PDBSymbol>
-DIASession::findSymbolByAddress(uint64_t Address, PDB_SymType Type) const {
+std::unique_ptr<PDBSymbol> DIASession::findSymbolByAddress(uint64_t Address,
+                                                           PDB_SymType Type) {
   enum SymTagEnum EnumVal = static_cast<enum SymTagEnum>(Type);
 
   CComPtr<IDiaSymbol> Symbol;
   if (S_OK != Session->findSymbolByVA(Address, EnumVal, &Symbol)) {
     ULONGLONG LoadAddr = 0;
     if (S_OK != Session->get_loadAddress(&LoadAddr))
       return nullptr;
     DWORD RVA = static_cast<DWORD>(Address - LoadAddr);
     if (S_OK != Session->findSymbolByRVA(RVA, EnumVal, &Symbol))
       return nullptr;
   }
   auto RawSymbol = std::make_unique<DIARawSymbol>(*this, Symbol);
   return PDBSymbol::create(*this, std::move(RawSymbol));
 }
 
 std::unique_ptr<PDBSymbol> DIASession::findSymbolByRVA(uint32_t RVA,
-                                                       PDB_SymType Type) const {
+                                                       PDB_SymType Type) {
   enum SymTagEnum EnumVal = static_cast<enum SymTagEnum>(Type);
 
   CComPtr<IDiaSymbol> Symbol;
   if (S_OK != Session->findSymbolByRVA(RVA, EnumVal, &Symbol))
     return nullptr;
 
   auto RawSymbol = std::make_unique<DIARawSymbol>(*this, Symbol);
   return PDBSymbol::create(*this, std::move(RawSymbol));
 }
 
 std::unique_ptr<PDBSymbol>
 DIASession::findSymbolBySectOffset(uint32_t Sect, uint32_t Offset,
-                                   PDB_SymType Type) const {
+                                   PDB_SymType Type) {
   enum SymTagEnum EnumVal = static_cast<enum SymTagEnum>(Type);
 
   CComPtr<IDiaSymbol> Symbol;
   if (S_OK != Session->findSymbolByAddr(Sect, Offset, EnumVal, &Symbol))
     return nullptr;
 
   auto RawSymbol = std::make_unique<DIARawSymbol>(*this, Symbol);
   return PDBSymbol::create(*this, std::move(RawSymbol));

llvm/lib/DebugInfo/PDB/Native/NativeFunctionSymbol.cpp

+//===- NativeFunctionSymbol.cpp - info about function symbols----*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/DebugInfo/PDB/Native/NativeFunctionSymbol.h"
+
+#include "llvm/DebugInfo/CodeView/SymbolRecord.h"
+#include "llvm/DebugInfo/PDB/Native/NativeTypeBuiltin.h"
+#include "llvm/DebugInfo/PDB/Native/NativeTypeEnum.h"
+
+using namespace llvm;
+using namespace llvm::codeview;
+using namespace llvm::pdb;
+
+NativeFunctionSymbol::NativeFunctionSymbol(NativeSession &Session,
+                                           SymIndexId Id, codeview::ProcSym Sym)
+    : NativeRawSymbol(Session, PDB_SymType::Data, Id), Sym(std::move(Sym)) {}
+
+NativeFunctionSymbol::~NativeFunctionSymbol() {}
+
+void NativeFunctionSymbol::dump(raw_ostream &OS, int Indent,
+                                PdbSymbolIdField ShowIdFields,
+                                PdbSymbolIdField RecurseIdFields) const {
+  NativeRawSymbol::dump(OS, Indent, ShowIdFields, RecurseIdFields);
+  dumpSymbolField(OS, "name", getName(), Indent);
+  dumpSymbolField(OS, "length", getLength(), Indent);
+  dumpSymbolField(OS, "offset", getAddressOffset(), Indent);
+  dumpSymbolField(OS, "section", getAddressSection(), Indent);
+}
+
+uint32_t NativeFunctionSymbol::getAddressOffset() const {
+  return Sym.CodeOffset;
+}
+
+uint32_t NativeFunctionSymbol::getAddressSection() const { return Sym.Segment; }
+std::string NativeFunctionSymbol::getName() const {
+  return std::string(Sym.Name);
+}
+
+PDB_SymType NativeFunctionSymbol::getSymTag() const {
+  return PDB_SymType::Function;
+}
+
+uint64_t NativeFunctionSymbol::getLength() const { return Sym.CodeSize; }
+
+uint32_t NativeFunctionSymbol::getRelativeVirtualAddress() const {
+  return Session.getRVAFromAddress(Sym.Segment, Sym.CodeOffset);
+}
+
+uint64_t NativeFunctionSymbol::getVirtualAddress() const {
+  return Session.getVAFromAddress(Sym.Segment, Sym.CodeOffset);
+}

llvm/lib/DebugInfo/PDB/Native/NativePublicSymbol.cpp

+//===- NativePublicSymbol.cpp - info about public symbols -------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/DebugInfo/PDB/Native/NativePublicSymbol.h"
+
+#include "llvm/DebugInfo/CodeView/SymbolRecord.h"
+#include "llvm/DebugInfo/PDB/Native/NativeTypeBuiltin.h"
+#include "llvm/DebugInfo/PDB/Native/NativeTypeEnum.h"
+
+using namespace llvm;
+using namespace llvm::codeview;
+using namespace llvm::pdb;
+
+NativePublicSymbol::NativePublicSymbol(NativeSession &Session, SymIndexId Id,
+                                       codeview::PublicSym32 Sym)
+    : NativeRawSymbol(Session, PDB_SymType::Data, Id), Sym(std::move(Sym)) {}
+
+NativePublicSymbol::~NativePublicSymbol() {}
+
+void NativePublicSymbol::dump(raw_ostream &OS, int Indent,
+                              PdbSymbolIdField ShowIdFields,
+                              PdbSymbolIdField RecurseIdFields) const {
+  NativeRawSymbol::dump(OS, Indent, ShowIdFields, RecurseIdFields);
+  dumpSymbolField(OS, "name", getName(), Indent);
+  dumpSymbolField(OS, "offset", getAddressOffset(), Indent);
+  dumpSymbolField(OS, "section", getAddressSection(), Indent);
+}
+
+uint32_t NativePublicSymbol::getAddressOffset() const { return Sym.Offset; }
+
+uint32_t NativePublicSymbol::getAddressSection() const { return Sym.Segment; }
+
+std::string NativePublicSymbol::getName() const {
+  return std::string(Sym.Name);
+}
+
+PDB_SymType NativePublicSymbol::getSymTag() const {
+  return PDB_SymType::PublicSymbol;
+}
+
+uint32_t NativePublicSymbol::getRelativeVirtualAddress() const {
+  return Session.getRVAFromAddress(Sym.Segment, Sym.Offset);
+}
+
+uint64_t NativePublicSymbol::getVirtualAddress() const {
+  return Session.getVAFromAddress(Sym.Segment, Sym.Offset);
+}

llvm/lib/DebugInfo/PDB/Native/NativeSession.cpp

 #include <algorithm>
 #include <cassert>
 #include <memory>
 #include <utility>
 
 using namespace llvm;
 using namespace llvm::msf;
 using namespace llvm::pdb;
+using namespace llvm::codeview;
 
 static DbiStream *getDbiStreamPtr(PDBFile &File) {
   Expected<DbiStream &> DbiS = File.getPDBDbiStream();
   if (DbiS)
     return &DbiS.get();
 
   consumeError(DbiS.takeError());
   return nullptr;

 bool NativeSession::addressForVA(uint64_t VA, uint32_t &Section,
                                  uint32_t &Offset) const {
   uint32_t RVA = VA - getLoadAddress();
   return addressForRVA(RVA, Section, Offset);
 }
 
 bool NativeSession::addressForRVA(uint32_t RVA, uint32_t &Section,
                                   uint32_t &Offset) const {
+  Section = 0;
+  Offset = 0;
+
   auto Dbi = Pdb->getPDBDbiStream();
   if (!Dbi)
     return false;
 
-  Section = 0;
-  Offset = 0;
-
   if ((int32_t)RVA < 0)
     return true;
 
   Offset = RVA;
   for (; Section < Dbi->getSectionHeaders().size(); ++Section) {
     auto &Sec = Dbi->getSectionHeaders()[Section];
     if (RVA < Sec.VirtualAddress)
       return true;
     Offset = RVA - Sec.VirtualAddress;
   }
   return true;
 }
 
 std::unique_ptr<PDBSymbol>
-NativeSession::findSymbolByAddress(uint64_t Address, PDB_SymType Type) const {
-  return nullptr;
+NativeSession::findSymbolByAddress(uint64_t Address, PDB_SymType Type) {
+  uint32_t Section;
+  uint32_t Offset;
+  addressForVA(Address, Section, Offset);
+  return findSymbolBySectOffset(Section, Offset, Type);
 }
 
-std::unique_ptr<PDBSymbol>
-NativeSession::findSymbolByRVA(uint32_t RVA, PDB_SymType Type) const {
-  return nullptr;
+std::unique_ptr<PDBSymbol> NativeSession::findSymbolByRVA(uint32_t RVA,
+                                                          PDB_SymType Type) {
+  uint32_t Section;
+  uint32_t Offset;
+  addressForRVA(RVA, Section, Offset);
+  return findSymbolBySectOffset(Section, Offset, Type);
 }
 
 std::unique_ptr<PDBSymbol>
 NativeSession::findSymbolBySectOffset(uint32_t Sect, uint32_t Offset,
-                                      PDB_SymType Type) const {
-  return nullptr;
+                                      PDB_SymType Type) {
+  return Cache.findSymbolByAddress(Sect, Offset, Type);
 }
 
 std::unique_ptr<IPDBEnumLineNumbers>
 NativeSession::findLineNumbers(const PDBSymbolCompiland &Compiland,
                                const IPDBSourceFile &File) const {
   return nullptr;
 }
 
if (ExeSymbol == 0)
     ExeSymbol = Cache.createSymbol<NativeExeSymbol>();
 }
 
 NativeExeSymbol &NativeSession::getNativeGlobalScope() const {
   const_cast<NativeSession &>(*this).initializeExeSymbol();
 
   return Cache.getNativeSymbolById<NativeExeSymbol>(ExeSymbol);
 }
+
+uint32_t NativeSession::getRVAFromAddress(uint32_t Section,
+                                          uint32_t Offset) const {
+  if (Section <= 0)
+    return 0;
+
+  auto Dbi = getDbiStreamPtr(*Pdb);
+  if (!Dbi)
+    return 0;
+
+  uint32_t MaxSection = Dbi->getSectionHeaders().size();
+  if (Section > MaxSection + 1)
+    Section = MaxSection + 1;
+  auto &Sec = Dbi->getSectionHeaders()[Section - 1];
+  return Sec.VirtualAddress + Offset;
+}
+
+uint64_t NativeSession::getVAFromAddress(uint32_t Section,
+                                         uint32_t Offset) const {
+  return LoadAddress + getRVAFromAddress(Section, Offset);
+}

llvm/lib/DebugInfo/PDB/Native/SymbolCache.cpp

 #include "llvm/DebugInfo/PDB/Native/SymbolCache.h"
 
+#include "llvm/DebugInfo/CodeView/DebugLinesSubsection.h"
 #include "llvm/DebugInfo/CodeView/SymbolDeserializer.h"
 #include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
 #include "llvm/DebugInfo/CodeView/TypeRecordHelpers.h"
 #include "llvm/DebugInfo/PDB/Native/DbiStream.h"
 #include "llvm/DebugInfo/PDB/Native/GlobalsStream.h"
+#include "llvm/DebugInfo/PDB/Native/ISectionContribVisitor.h"
+#include "llvm/DebugInfo/PDB/Native/ModuleDebugStream.h"
 #include "llvm/DebugInfo/PDB/Native/NativeCompilandSymbol.h"
 #include "llvm/DebugInfo/PDB/Native/NativeEnumGlobals.h"
 #include "llvm/DebugInfo/PDB/Native/NativeEnumTypes.h"
+#include "llvm/DebugInfo/PDB/Native/NativeFunctionSymbol.h"
+#include "llvm/DebugInfo/PDB/Native/NativePublicSymbol.h"
 #include "llvm/DebugInfo/PDB/Native/NativeRawSymbol.h"
 #include "llvm/DebugInfo/PDB/Native/NativeSession.h"
 #include "llvm/DebugInfo/PDB/Native/NativeTypeArray.h"
 #include "llvm/DebugInfo/PDB/Native/NativeTypeBuiltin.h"
 #include "llvm/DebugInfo/PDB/Native/NativeTypeEnum.h"
 #include "llvm/DebugInfo/PDB/Native/NativeTypeFunctionSig.h"
 #include "llvm/DebugInfo/PDB/Native/NativeTypePointer.h"
 #include "llvm/DebugInfo/PDB/Native/NativeTypeTypedef.h"
 #include "llvm/DebugInfo/PDB/Native/NativeTypeUDT.h"
 #include "llvm/DebugInfo/PDB/Native/NativeTypeVTShape.h"
 #include "llvm/DebugInfo/PDB/Native/PDBFile.h"
+#include "llvm/DebugInfo/PDB/Native/PublicsStream.h"
 #include "llvm/DebugInfo/PDB/Native/SymbolStream.h"
 #include "llvm/DebugInfo/PDB/Native/TpiStream.h"
 #include "llvm/DebugInfo/PDB/PDBSymbol.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolCompiland.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolTypeEnum.h"
 
 using namespace llvm;
 using namespace llvm::codeview;
uint32_t Size;
     {codeview::SimpleTypeKind::Float64, PDB_BuiltinType::Float, 8},
     {codeview::SimpleTypeKind::Float80, PDB_BuiltinType::Float, 10},
     {codeview::SimpleTypeKind::Boolean8, PDB_BuiltinType::Bool, 1},
     // This table can be grown as necessary, but these are the only types we've
     // needed so far.
 };
 
 SymbolCache::SymbolCache(NativeSession &Session, DbiStream *Dbi)
-    : Session(Session), Dbi(Dbi) {
+    : Session(Session), Dbi(Dbi), AddrToModuleIndex(IMapAllocator) {
   // Id 0 is reserved for the invalid symbol.
   Cache.push_back(nullptr);
 
   if (Dbi)
     Compilands.resize(Dbi->modules().getModuleCount());
 }
 
 std::unique_ptr<IPDBEnumSymbols>
SymIndexId SymbolCache::getOrCreateGlobalSymbolByOffset(uint32_t Offset) {
   if (Id != 0) {
     assert(GlobalOffsetToSymbolId.count(Offset) == 0);
     GlobalOffsetToSymbolId[Offset] = Id;
   }
 
   return Id;
 }
 
+std::unique_ptr<PDBSymbol> SymbolCache::findSymbolByAddress(uint32_t Sect,
+                                                            uint32_t Offset,
+                                                            PDB_SymType Type) {
+  if (AddrToModuleIndex.empty())
+    parseSectionContribs();
+
+  // FIXME: Implement for PDB_SymType::Data.
+  switch (Type) {
+  case PDB_SymType::Function:
+    return findFunctionSymbolByAddress(Sect, Offset);
+  case PDB_SymType::PublicSymbol:
+    return findPublicSymbolByAddress(Sect, Offset);
+  case PDB_SymType::None: {
+    if (auto Sym = findFunctionSymbolByAddress(Sect, Offset))
+      return Sym;
+    if (auto Sym = findPublicSymbolByAddress(Sect, Offset))
+      return Sym;
+    return nullptr;
+  default:
+    return nullptr;
+  }
+  }
+}
+
+std::unique_ptr<PDBSymbol>
+SymbolCache::findFunctionSymbolByAddress(uint32_t Sect, uint32_t Offset) {
+  auto Iter = AddressToFunctionSymId.find({Sect, Offset});
+  if (Iter != AddressToFunctionSymId.end())
+    return getSymbolById(Iter->second);
+
+  if (!Dbi)
+    return nullptr;
+
+  auto Modi = getModuleIndexForAddr(Sect, Offset);
+  if (!Modi)
+    return nullptr;
+
+  DbiModuleDescriptor ModDesc = Dbi->modules().getModuleDescriptor(*Modi);
+  uint16_t StreamIndex = ModDesc.getModuleStreamIndex();
+  if (StreamIndex == kInvalidStreamIndex)
+    return nullptr;
+  auto ModStreamData = Session.getPDBFile().createIndexedStream(StreamIndex);
+  ModuleDebugStreamRef ModS(ModDesc, std::move(ModStreamData));
+  if (auto EC = ModS.reload()) {
+    consumeError(std::move(EC));
+    return nullptr;
+  }
+
+  // Search for the symbol in this module.
+  for (auto &Sym : ModS.getSymbolArray()) {
+    if (Sym.kind() != S_LPROC32 && Sym.kind() != S_GPROC32)
+      continue;
+    auto PS = cantFail(SymbolDeserializer::deserializeAs<ProcSym>(Sym));
+    if (PS.Segment == Sect && PS.CodeOffset == Offset) {
+      SymIndexId Id = createSymbol<NativeFunctionSymbol>(std::move(PS));
+      return getSymbolById(Id);
+    }
+  }
+  return nullptr;
+}
+
+std::unique_ptr<PDBSymbol>
+SymbolCache::findPublicSymbolByAddress(uint32_t Sect, uint32_t Offset) {
+  auto Iter = AddressToPublicSymId.find({Sect, Offset});
+  if (Iter != AddressToPublicSymId.end())
+    return getSymbolById(Iter->second);
+
+  auto Publics = Session.getPDBFile().getPDBPublicsStream();
+  if (!Publics)
+    return nullptr;
+
+  auto ExpectedSyms = Session.getPDBFile().getPDBSymbolStream();
+  if (!ExpectedSyms)
+    return nullptr;
+  BinaryStreamRef SymStream =
+      ExpectedSyms->getSymbolArray().getUnderlyingStream();
+
+  // Binary search for the symbol in the publics address map, which is sorted
+  // by section and offset.
+  size_t Start = 0;
+  size_t End = Publics->getAddressMap().size();
+  while (Start < End) {
+    size_t I = Start + (End - Start) / 2;
+    Expected<CVSymbol> Sym = readSymbolFromStream(SymStream, I);
+    if (!Sym) {
+      consumeError(Sym.takeError());
+      return nullptr;
+    }
+    auto PS =
+        cantFail(SymbolDeserializer::deserializeAs<PublicSym32>(Sym.get()));
+    if (PS.Segment == Sect && PS.Offset == Offset)
+      return getSymbolById(createSymbol<NativePublicSymbol>(std::move(PS)));
+
+    if (PS.Segment < Sect || (PS.Segment == Sect && PS.Offset < Offset))
+      End = I;
+    else
+      Start = I + 1;
+  }
+  return nullptr;
+}
+
 std::unique_ptr<PDBSymbolCompiland>
 SymbolCache::getOrCreateCompiland(uint32_t Index) {
   if (!Dbi)
     return nullptr;
 
   if (Index >= Compilands.size())
     return nullptr;
 
   if (Compilands[Index] == 0) {
     const DbiModuleList &Modules = Dbi->modules();
     Compilands[Index] =
         createSymbol<NativeCompilandSymbol>(Modules.getModuleDescriptor(Index));
   }
 
   return Session.getConcreteSymbolById<PDBSymbolCompiland>(Compilands[Index]);
 }
+
+void SymbolCache::parseSectionContribs() {
+  if (!Dbi)
+    return;
+
+  class Visitor : public ISectionContribVisitor {
+    NativeSession &Session;
+    IntervalMap<uint32_t, uint16_t> &IMap;
+
+  public:
+    Visitor(NativeSession &Session, IntervalMap<uint32_t, uint16_t> &IMap)
+        : Session(Session), IMap(IMap) {}
+    void visit(const SectionContrib &C) override {
+      if (C.Size == 0)
+        return;
+
+      uint64_t VA = Session.getVAFromAddress(C.ISect, C.Off);
+      uint64_t End = VA + C.Size;
+      IMap.insert(VA, End - 1, C.Imod);
+    }
+    void visit(const SectionContrib2 &C) override { visit(C.Base); }
+  };
+
+  Visitor V(Session, AddrToModuleIndex);
+  Dbi->visitSectionContributions(V);
+}
+
+Optional<uint16_t> SymbolCache::getModuleIndexForAddr(uint32_t Sect,
+                                                      uint32_t Offset) const {
+  auto Iter = AddrToModuleIndex.find(Session.getVAFromAddress(Sect, Offset));
+  if (Iter == AddrToModuleIndex.end())
+    return None;
+  return Iter.value();
+}

llvm/lib/DebugInfo/Symbolize/Symbolize.cpp

LLVMSymbolizer::getOrCreateModuleInfo(const std::string &ModuleName) {
   // symbolize. Otherwise, use DWARF.
   if (auto CoffObject = dyn_cast<COFFObjectFile>(Objects.first)) {
     const codeview::DebugInfo *DebugInfo;
     StringRef PDBFileName;
     auto EC = CoffObject->getDebugPDBInfo(DebugInfo, PDBFileName);
     if (!EC && DebugInfo != nullptr && !PDBFileName.empty()) {
       using namespace pdb;
       std::unique_ptr<IPDBSession> Session;
-      if (auto Err = loadDataForEXE(PDB_ReaderType::DIA,
-                                    Objects.first->getFileName(), Session)) {
+      PDB_ReaderType ReaderType = Opts.UseNativePDBReader
+                                      ? PDB_ReaderType::Native
+                                      : PDB_ReaderType::DIA;
+      if (auto Err = loadDataForEXE(ReaderType, Objects.first->getFileName(),
+                                    Session)) {
         Modules.emplace(ModuleName, std::unique_ptr<SymbolizableModule>());
         // Return along the PDB filename to provide more context
         return createFileError(PDBFileName, std::move(Err));
       }
       Context.reset(new PDBContext(*CoffObject, std::move(Session)));
     }
   }
   if (!Context)

llvm/test/tools/llvm-symbolizer/pdb/pdb-native.test

+RUN: echo 0x401380 > %t.input
+RUN: echo 0x401390 >> %t.input
+RUN: echo 0x4013A0 >> %t.input
+RUN: echo 0x4013C0 >> %t.input
+RUN: echo 0x4013D0 >> %t.input
+RUN: echo 0x4013E0 >> %t.input
+RUN: echo 0x4013F0 >> %t.input
+RUN: echo 0x401420 >> %t.input
+RUN: llvm-symbolizer -obj="%p/Inputs/test.exe" -use-native-pdb-reader < %t.input \
+RUN:    | FileCheck %s
+RUN: llvm-symbolizer -obj="%p/Inputs/test.exe" -demangle=false -use-native-pdb-reader < %t.input \
+RUN:    | FileCheck %s --check-prefix=CHECK-NO-DEMANGLE
+
+Subtract ImageBase from all the offsets and run the test again with
+--relative-address.
+
+RUN: %python -c 'import sys;print("\n".join([hex(int(x, 16) - 0x400000) for x in sys.stdin]))' < %t.input \
+RUN:    | llvm-symbolizer -obj="%p/Inputs/test.exe" -use-native-pdb-reader -demangle=false --relative-address \
+RUN:    | FileCheck %s --check-prefix=CHECK-NO-DEMANGLE
+
+Currently only finding function/public symbol names is implemented.
+
+CHECK: foo(void)
+CHECK: {{^private_symbol$}}
+CHECK: {{^main}}
+CHECK: {{^foo_cdecl$}}
+CHECK: {{^foo_stdcall$}}
+CHECK: {{^foo_fastcall$}}
+CHECK: {{^foo_vectorcall$}}
+CHECK: NS::Foo::bar(void)
+
+CHECK-NO-DEMANGLE: ?foo@@YAXXZ
+CHECK-NO-DEMANGLE: private_symbol
+CHECK-NO-DEMANGLE: _main
+CHECK-NO-DEMANGLE: _foo_cdecl
+CHECK-NO-DEMANGLE: _foo_stdcall@0
+CHECK-NO-DEMANGLE: @foo_fastcall@0
+CHECK-NO-DEMANGLE: foo_vectorcall@@0
+CHECK-NO-DEMANGLE: ?bar@Foo@NS@@QAEXXZ

llvm/tools/llvm-symbolizer/llvm-symbolizer.cpp

 static cl::opt<DIPrinter::OutputStyle>
     ClOutputStyle("output-style", cl::init(DIPrinter::OutputStyle::LLVM),
                   cl::desc("Specify print style"),
                   cl::values(clEnumValN(DIPrinter::OutputStyle::LLVM, "LLVM",
                                         "LLVM default style"),
                              clEnumValN(DIPrinter::OutputStyle::GNU, "GNU",
                                         "GNU addr2line style")));
 
+static cl::opt<bool>
+    ClUseNativePDBReader("use-native-pdb-reader", cl::init(0),
+                         cl::desc("Use native PDB functionality"));
+
 static cl::extrahelp
     HelpResponse("\nPass @FILE as argument to read options from FILE.\n");
 
 template<typename T>
 static bool error(Expected<T> &ResOrErr) {
   if (ResOrErr)
     return false;
   logAllUnhandledErrors(ResOrErr.takeError(), errs(),
int main(int argc, char **argv) {
   Opts.UseSymbolTable = ClUseSymbolTable;
   Opts.Demangle = ClDemangle;
   Opts.RelativeAddresses = ClUseRelativeAddress;
   Opts.UntagAddresses = ClUntagAddresses;
   Opts.DefaultArch = ClDefaultArch;
   Opts.FallbackDebugPath = ClFallbackDebugPath;
   Opts.DWPName = ClDwpName;
   Opts.DebugFileDirectory = ClDebugFileDirectory;
+  Opts.UseNativePDBReader = ClUseNativePDBReader;
   Opts.PathStyle = DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath;
   // If both --basenames and --relativenames are specified then pick the last
   // one.
   if (ClBasenames.getPosition() > ClRelativenames.getPosition())
     Opts.PathStyle = DILineInfoSpecifier::FileLineInfoKind::BaseNameOnly;
   else if (ClRelativenames)
     Opts.PathStyle = DILineInfoSpecifier::FileLineInfoKind::RelativeFilePath;
 

llvm/unittests/DebugInfo/PDB/NativeSessionTest.cpp

 //===- llvm/unittest/DebugInfo/PDB/NativeSessionTest.cpp ------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/PDB/Native/NativeSession.h"
 #include "llvm/DebugInfo/PDB/IPDBSession.h"
 #include "llvm/DebugInfo/PDB/PDB.h"
+#include "llvm/DebugInfo/PDB/PDBSymbolFunc.h"
+#include "llvm/DebugInfo/PDB/PDBSymbolPublicSymbol.h"
 #include "llvm/Support/Path.h"
 
 #include "llvm/Testing/Support/Error.h"
 
 #include "gtest/gtest.h"
 
 #include <vector>
 
 using namespace llvm;
 using namespace llvm::pdb;
 
 extern const char *TestMainArgv0;
 
 static std::string getExePath() {
   SmallString<128> InputsDir = unittest::getInputFileDirectory(TestMainArgv0);
   llvm::sys::path::append(InputsDir, "SimpleTest.exe");
   return std::string(InputsDir);
 }
 
 TEST(NativeSessionTest, TestCreateFromExe) {
   std::unique_ptr<IPDBSession> S;
-  // Tests that the PDB file can be found if it is in the same directory as the
-  // executable.
-  Error E = pdb::loadDataForEXE(PDB_ReaderType::Native, getExePath(), S);
+  std::string ExePath = getExePath();
+  Expected<std::string> PdbPath = NativeSession::searchForPdb({ExePath});
+  ASSERT_TRUE((bool)PdbPath);
+
+  Error E = NativeSession::createFromPdbPath(PdbPath.get(), S);
   ASSERT_THAT_ERROR(std::move(E), Succeeded());
 }
 
 TEST(NativeSessionTest, TestSetLoadAddress) {
   std::unique_ptr<IPDBSession> S;
   Error E = pdb::loadDataForEXE(PDB_ReaderType::Native, getExePath(), S);
   ASSERT_THAT_ERROR(std::move(E), Succeeded());
 

llvm/unittests/DebugInfo/PDB/PDBApiTest.cpp

class MockSession : public IPDBSession {
   bool addressForVA(uint64_t VA, uint32_t &Section,
                     uint32_t &Offset) const override {
     return false;
   }
   bool addressForRVA(uint32_t RVA, uint32_t &Section,
                      uint32_t &Offset) const override {
     return false;
   }
-  std::unique_ptr<PDBSymbol>
-  findSymbolByAddress(uint64_t Address, PDB_SymType Type) const override {
+  std::unique_ptr<PDBSymbol> findSymbolByAddress(uint64_t Address,
+                                                 PDB_SymType Type) override {
     return nullptr;
   }
   std::unique_ptr<PDBSymbol> findSymbolByRVA(uint32_t RVA,
-                                             PDB_SymType Type) const override {
+                                             PDB_SymType Type) override {
     return nullptr;
   }
-  std::unique_ptr<PDBSymbol>
-  findSymbolBySectOffset(uint32_t Sect, uint32_t Offset,
-                         PDB_SymType Type) const override {
+  std::unique_ptr<PDBSymbol> findSymbolBySectOffset(uint32_t Sect,
+                                                    uint32_t Offset,
+                                                    PDB_SymType Type) override {
     return nullptr;
   }
   std::unique_ptr<IPDBEnumLineNumbers>
   findLineNumbers(const PDBSymbolCompiland &Compiland,
                   const IPDBSourceFile &File) const override {
     return nullptr;
   }
   std::unique_ptr<IPDBEnumLineNumbers>

llvm/utils/gn/secondary/llvm/lib/DebugInfo/PDB/BUILD.gn

sources = [
     "Native/ModuleDebugStream.cpp",
     "Native/NamedStreamMap.cpp",
     "Native/NativeCompilandSymbol.cpp",
     "Native/NativeEnumGlobals.cpp",
     "Native/NativeEnumInjectedSources.cpp",
     "Native/NativeEnumModules.cpp",
     "Native/NativeEnumTypes.cpp",
     "Native/NativeExeSymbol.cpp",
+    "Native/NativeFunctionSymbol.cpp",
+    "Native/NativePublicSymbol.cpp",
     "Native/NativeRawSymbol.cpp",
     "Native/NativeSession.cpp",
     "Native/NativeSymbolEnumerator.cpp",
     "Native/NativeTypeArray.cpp",
     "Native/NativeTypeBuiltin.cpp",
     "Native/NativeTypeEnum.cpp",
     "Native/NativeTypeFunctionSig.cpp",
     "Native/NativeTypePointer.cpp",