This is an archive of the discontinued LLVM Phabricator instance.

Differential D7356

Initial pass at API design for DebugInfo/PDB
ClosedPublic

Authored by zturner on Feb 2 2015, 1:30 PM.

Details

Reviewers
amccarth
chandlerc
compnerd
dblaikie
echristo
rnk
Commits
rG0e9e66330a20: Resubmit "Create lib/DebugInfo/PDB" (r228428)
rG079ba9224fd2: Create lib/DebugInfo/PDB.
rL228435: Resubmit "Create lib/DebugInfo/PDB" (r228428)
rL228428: Create lib/DebugInfo/PDB.
Summary

*IN PROGRESS* This is in progress and is not supposed to be final. Many interfaces are incomplete / unimplemented. I'm submitting this early to solicit comments on the overall design, so that anyone interested can help shape the design of the library.

I approached this design with the following assumptions in mind:

  1. The interface to the PDB reading code should expose no Windows-specific types.
  2. LLVMDebugInfoPDB should compile on non-Windows
  3. LLVMDebugInfoPDB should support multiple simultaneous implementations of a PDB reader, and you should be able to choose which one you create at runtime.

#1 means that, essentially, I need to "shim" or clone the interface to DIA. A full description of DIA and its available interfaces can be found here: https://msdn.microsoft.com/en-us/library/108e9y6d.aspx. Since DIA is COM-based, there is really no way to hide the Windows nature of these methods and interfaces without making an entirely new interface that looks about the same, and has a DIA version as one possible implementation.

#3 is assumed in order to leave open the possibility that someone in the future may create a different implementation of this PDB reader. Even if that happens though, I believe we may still want a DIA-based version of the itnerface in the code. The reason for this is to make it possible to understand how PDBs evolve with new versions of Visual Studio and new releases of the DIA SDK which expose new functionality which may not be recognized by a non-DIA based implementation.

The DIA SDK has a somewhat awkward object model, so before thinking about this patch it helps to understand at a fundamental level how PDBs are queried in DIA. The full set of interfaces is at the aforementioned URL, but one of those interfaces is of particular importance. The IDiaSymbol interface [https://msdn.microsoft.com/en-us/library/w0edf0x4.aspx]. This is the *only* access to symbols in the PDB. This means functions, executables, global variables, and more are all queried through this interface (A complete list of symbol types is enumerated in the PDB_SymType enum included in this patch). The value of this enum for a particular symbol determines which subset of methods on the IDiaSymbol are valid to call. For example, the methods which are valid to call on an IDiaSymbol whose symbol type is PDB_SymType::Function are documented here [https://msdn.microsoft.com/en-us/library/62w760s9.aspx].

I have attempted to model this in my patch as follows:

  1. An abstract interface named IPDBSymbolBase includes the same set of methods defined by IDiaSymbol. Implementers of a particular PDB reading strategy (e.g. DIA) are expected to implement this interface.
  2. For each concrete symbol type, a non-abstract class is provided. In this initial patch, this includes PDBFunction and PDBExecutable, which expose the exact set of methods that are valid for that symbol type. This is essentially a wrapper about the base type, whose purpose is to limit the set of methods which the user can call.
  3. A user can obtain one of the concrete wrapper types by either manually constructing it with an IPDBSymbolBase pointer, or by using a dyn_cast<> like template called pdb_symbol_cast<>.

Note that DIA provides access to other information from a PDB that is not just symbols. For example, line numbers, source files, and various other things are simply independent interfaces and do not follow this tag-based / casting model. For those, I have simply cloned the interface and will expect the implementor to provide an implementation, and the user to use it through a base pointer.

Sorry for the long winded introduction, but since some people on this list have 0 experience with DIA, I hope this helps. I'm open to completely gutting this / re-working it if people think a different design would be more appropriate.

Diff Detail

Repository
rL LLVM

Event Timeline

zturner updated this revision to Diff 19185.Feb 2 2015, 1:30 PM
zturner retitled this revision from to Initial pass at API design for DebugInfo/PDB.
zturner updated this object.
zturner edited the test plan for this revision. (Show Details)
zturner added reviewers: dblaikie, echristo, rnk, chandlerc, amccarth, compnerd.
zturner added a subscriber: Unknown Object (MLST).
zturner added a comment.Feb 2 2015, 1:34 PM

The value of this enum for a particular symbol determines which subset of methods on the IDiaSymbol are valid to call.

One additional point about this line. The subset of methods which are valid to call for a particular IDiaSymbol is not easy to organize into a useful object hierarchy. For some values of the tag field, the subsets will be disjoint, while for others they will overlap, and for others they might even be the same. If you take the intersection across all tag values, for example, the only common method will be the function which actually returns the tag value.

So it's difficult to organize this into a meaningful object hierarchy.

dblaikie edited edge metadata.Feb 2 2015, 2:36 PM

Few random comments provided.

include/llvm/DebugInfo/PDB/IPDBDataStream.h
23 ↗(On Diff #19185)

In theory the LLVM coding convention requires that types with vtables have an anchor function (one non-inline virtual function).

I'm not sure if the type /only/ has pure virtual functions whether that matters (but it probably does - even a vtable of only pure virtual functions still has to exist, I think)

25 ↗(On Diff #19185)

This is the total number of things this stream will visit? (or the number remaining? or the current index?)

26 ↗(On Diff #19185)

What's this the name of?

27 ↗(On Diff #19185)

I take it this returns the current item but doesn't move the cursor? Maybe it should be const?

28 ↗(On Diff #19185)

return Optional<RecordType> rather than an out parameter?

(I'd probably call this "next" but that might be a bit vague (& collides with std::next))

include/llvm/DebugInfo/PDB/IPDBSourceFile.h
32 ↗(On Diff #19185)

missing newline at end of file

include/llvm/DebugInfo/PDB/IPDBSymbolBase.h
25 ↗(On Diff #19185)

Wouldn't this return value be passing ownership (via unique_ptr or similar)? and similarly on the next two functions.

include/llvm/DebugInfo/PDB/PDBTypes.h
27 ↗(On Diff #19185)

Not sure if these typedefs help readability - it feels like they hinder it by hiding a common construct (unique_ptr) in something opaque when reading the code. But I tend to be a bit verbose...

zturner added inline comments.Feb 2 2015, 2:43 PM
include/llvm/DebugInfo/PDB/IPDBDataStream.h
25 ↗(On Diff #19185)

The former. It's the total number of times it's valid to call getNext() if you're at the beginning of the stream (when it's newly constructed, or you've just called reset).

26 ↗(On Diff #19185)

The name of the data stream (which in turn identifies what kind of data it has). The stream named "FPO" for example, contains fpo data.

27 ↗(On Diff #19185)

In theory it probably could be, but the underlying DIA interface doesn't have any const methods. I could probably use const on almost every single method of IPDBSymbol if we're ok const_casting. I didn't make anything const though since the underlying DIA interface has no const methods.

Since you poitned out this method though, I also noticed that I left off the index.

include/llvm/DebugInfo/PDB/IPDBSymbolBase.h
25 ↗(On Diff #19185)

Yes, thanks. I forgot to update these to return unique_ptrs.

include/llvm/DebugInfo/PDB/PDBTypes.h
27 ↗(On Diff #19185)

Does llvm tend to write out unique_ptr<T> everywhere? It leads to a lot of line wrapping.

dblaikie added inline comments.Feb 2 2015, 2:57 PM
include/llvm/DebugInfo/PDB/IPDBDataStream.h
25 ↗(On Diff #19185)

Not sure if there might be a better name for this. (size()?)

26 ↗(On Diff #19185)

Is that useful to clients? Would there be a better API like just having different types (templated, perhaps) of streams?

27 ↗(On Diff #19185)

Chances are you won't need to const_cast much since you'll have indirection to the underlying API anyway, I assume (the concrete implementation of this interface will have a member pointer to some DIA structure, right? And you call functions on the thing pointed to - since const isn't "deep" that'll just work without const_cast)

(open question about the threading guarantees of the underlying DIA APIs, though - if those operations that are conceptually const but not marked const in the DIA API are not thread safe, that might surprise users of this API to call a non-thread-safe const function, but if that's the case, a comment that this whole API is thread incompatible would be fine I think)

include/llvm/DebugInfo/PDB/PDBTypes.h
27 ↗(On Diff #19185)

I think so, at least in my experience - but I don't claim to have lots of data.

(I tend to be much more conservative about using typedefs (rarely use them) than most people, so feel free to treat this feedback with a grain of salt)

zturner added inline comments.Feb 2 2015, 3:10 PM
include/llvm/DebugInfo/PDB/IPDBDataStream.h
26 ↗(On Diff #19185)

I actually pondered not including access to the underlying streams at all. The reason is that the streams simply provide access to the raw bytes in the PDB file. All of the information present in the streams is available through the typed methods as well. But I figured it was useful still for the dumper. From what I can tell, the dumper will be the only real client of the stream data, so just returning the name sems kind of reasonable. Another thing is that it's not documented what all of the different streams that might be returned are. So far I've observed a few different ones through some dumps I've run on my own, but they're not always the same, so there could be some we don't know about.

zturner added a comment.Feb 2 2015, 3:40 PM

As an aside, one thing I actually thought about with regards to the object model was only including 1 method in the base class. the one that gets the symbol tag. Then having each concrete type derive from the base tag and then provide pure virtual methods for the methods that it would support. So instead of having this PDBFunction, for example, which is ultimately just a facade that forwards methods to the underlying monolithic interface, instead have an IPDBFunction whose vtable contains the exact set of methods relevant for a function.

The advantages of this approach is that

  1. you can no longer call invalid methods through the IPDBSymbolBase interface.
  2. pdb_symbol_cast<> has more natural behavior now. Instead of casting a pointer type to a value type, it actually behaves more like a traditional dynamic cast.

And the disadvantages are:

  1. Implementor has to do more work now. It has to implement the same function many times, for example when valid methods overlap.
zturner updated this revision to Diff 19247.Feb 3 2015, 10:42 AM
zturner edited edge metadata.

Addressed all (I think?) of David's comments.

dblaikie added inline comments.Feb 3 2015, 11:25 AM
include/llvm/DebugInfo/PDB/PDBCasting.h
28 ↗(On Diff #19247)

This cast machinery seems a bit confusing owing to the mix of pointers and value types. (& you mention in the summary that you can also use the traditional llvm::*cast machinery too? That would be odd as well - to cast to concrete types from pointer types)

One other way that PDBFunction et, al could be implemented that might be more natural (& require less of this machinery) - make PDBSymbol opaque (virtual dtor, no other functions) and have various PDBFunction/etc derive from that. Use LLVM's standard cast machinery here. Implement them in terms of a PDBRawSymbol/PDBSymbolImpl, something like that (which would be what your current PDBSymbol is) - maybe the base opaque PDBSymbol could have a non-virtual "getRaw/getImpl/whatever" to access the raw thing when desired (in dumpers, etc).

I just hesitate to add more 'odd' casting machinery - we already stretch that idiom a bit further than I think is helpful with some of our hierarchies.

lib/DebugInfo/PDB/PDBInterfaceAnchors.cpp
21 ↗(On Diff #19247)

I don't think you need an out-of-line ctor /and/ dtor, just the dtor would be fine - and maybe a comment about these dtors being anchors.

zturner updated this revision to Diff 19275.Feb 3 2015, 2:50 PM

Reworked the class hierarchy per David's suggestions. Library now should work with llvm::isa<> and llvm::dyn_cast<> instead of relying on custom casting machinery. This was done by injecting a new base class below all the concrete PDBFunction / etc types.

dblaikie added inline comments.Feb 3 2015, 3:05 PM
include/llvm/DebugInfo/PDB/IPDBEnumChildren.h
24 ↗(On Diff #19275)

Name's OK, but "count" still seems like it might be a bit ambiguous with index, or number remaining. Another option (which seems more idiomatic in LLVM) might be "getNumChildren" (while I would like "size()" it's annoying that the count is attached to the iterator and not to some separate structure that produces iterators and I don't know how to properly communicate the separation of these concepts, unfortunately)

include/llvm/DebugInfo/PDB/IPDBRawSymbol.h
193 ↗(On Diff #19275)

How're these functions going to communicate failure?

include/llvm/DebugInfo/PDB/PDBSymbol.h
33 ↗(On Diff #19275)

return by reference rather than pointer here, perhaps?

46 ↗(On Diff #19275)

could probably make this private and the derived classes can just call "getRawSymbol" - the derived classes don't need the ability to mutate (null, repoint, etc) this variable. (optional, not a big deal either way, just a little more stringent encapsulation)

The member could actually be const, too/instead.

lib/DebugInfo/PDB/PDB.cpp
20 ↗(On Diff #19275)

"return nullptr" will work here

zturner added inline comments.Feb 3 2015, 3:11 PM
include/llvm/DebugInfo/PDB/IPDBRawSymbol.h
193 ↗(On Diff #19275)

Undefined in theory, probably false in practice. You shouldn't call methods on the raw interface unless you know it's a valid method.

For the purposes of a dumper who wanted to detect unknown / unexpected fields, that knowledge could all be encapsulated in the implementation of the raw interface. For example, you could have PDBSymbol::dump() which calls RawSymbol->dump(), and that particular implementation can go to the native API instead of calling the friendly accessors.

zturner added a comment.Feb 3 2015, 3:25 PM

I was thinking it might still be useful for people who knew what they were
doing and who wanted to write some implementation-specific code to be able
to get at the native native interface. Like in this case a raw COM
pointer. In theory this shouldn't ever be necessary, but it's hard to say
without knowing anything about implementation strategies other than DIA how
much compatibility someone would be able to achieve, and if there ever
might be things that are only possible to implement in terms of one API but
not the other. So I didn't want to prematurely remove the possibility to
get at the native interface, for example by writing
static_cast<DIASymbol*>(PDBSymbol::getRawSymbol())->someDIAOnlyMethod().

zturner updated this revision to Diff 19361.Feb 4 2015, 3:51 PM

Ok this CL just got way bigger, but it should be fairly complete in terms of stuff that will live in the generic API. There is now one concrete implementation of PDBSymbol for every tag value, and this uses some macro C++11 magic to forward the calls through to the underlying raw interface.

Additionally, this provides a unit test which uses a mock implementation of the underlying raw symbol to verify that the dyncast semantics are as expected. Confirmed that the unit tests are hooked up correctly, as I changed one line in the test to something that would obviously fail, and my test failed.

zturner added a comment.Feb 6 2015, 9:26 AM

ping. Don't expect you to read through this whole patch again thoroughly since it's gotten long, but I think all issues have been addressed. And many of the files are fairly boilerplate. LMK if you're ok with this going in.

dblaikie accepted this revision.Feb 6 2015, 10:10 AM
dblaikie edited edge metadata.

Few optional bits of feedback but otherwise seems fine.

If you want some more help/details on the .def stuff, let me know - happy to go through it.

lib/DebugInfo/PDB/PDBInterfaceAnchors.cpp
64 ↗(On Diff #19361)

This still means the vtable is emitted weakly, though it will only be emitted in one place. So this doesn't quite meet the style guide's requirement & I'd rather use the virtual dtor or an explicit anchor function, but I'm not so fussed. I do think the rule is a bit silly, but I'm not sure this particular approach is worthwhile (I suppose my thought is that the rule is silly enough that it's not worth partly/tangentially/sort-of adhering to, might as well just not bother adhering to it at all, perhaps - I dunno)

lib/DebugInfo/PDB/PDBSymbol.cpp
56 ↗(On Diff #19361)

Could possibly move the #define closer to the use (even inside the function) and maybe undef it afterwards.

63 ↗(On Diff #19361)

Would it be useful to do this more as a .def file style - Take a look at Duncan's recent use of include/llvm/IR/Metadata.def for an example (essentially have the big long list of all the PDBSymbols written once, in one file - then #define a macro for what you want to do with those names, then include the file - thus stamping out all sorts of things you want, for all PDBSymbols)

unittests/DebugInfo/PDB/PDBApiTest.cpp
53 ↗(On Diff #19361)

Probably prefer the LHS return type. The only reason to use the -> return type formulation is if you want to refer to function parameters, generally.

Also, rather than casting nullptr, the usual way to "give me a thing of some particular kind in an unevaluated context" is a utility called declval:

decltype(declval<IPDBRawSymbol>().Func()) Func() const override {
62 ↗(On Diff #19361)

Use override rather than virtual (for all of these).

This revision is now accepted and ready to land.Feb 6 2015, 10:10 AM
Closed by commit rL228428: Create lib/DebugInfo/PDB. (authored by zturner). · Explain WhyFeb 6 2015, 11:45 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

Diff 19502

llvm/trunk/include/llvm/DebugInfo/PDB/IPDBDataStream.h

//===- IPDBDataStream.h - base interface for child enumerator -*- C++ ---*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_IPDBDATASTREAM_H
#define LLVM_DEBUGINFO_PDB_IPDBDATASTREAM_H
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/Optional.h"
#include "PDBTypes.h"
namespace llvm {
/// IPDBDataStream defines an interface used to represent a stream consisting
/// of a name and a series of records whose formats depend on the particular
/// stream type.
class IPDBDataStream {
public:
typedef llvm::SmallVector<uint8_t, 32> RecordType;
virtual ~IPDBDataStream();
virtual uint32_t getRecordCount() const = 0;
virtual std::string getName() const = 0;
virtual llvm::Optional<RecordType> getItemAtIndex(uint32_t Index) const = 0;
virtual bool getNext(RecordType &Record) = 0;
virtual void reset() = 0;
virtual std::unique_ptr<IPDBDataStream> clone() const = 0;
};
}
#endif

llvm/trunk/include/llvm/DebugInfo/PDB/IPDBEnumChildren.h

//===- IPDBEnumChildren.h - base interface for child enumerator -*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_IPDBENUMCHILDREN_H
#define LLVM_DEBUGINFO_PDB_IPDBENUMCHILDREN_H
#include <memory>
#include "PDBTypes.h"
namespace llvm {
template <typename ChildType> class IPDBEnumChildren {
public:
typedef std::unique_ptr<ChildType> ChildTypePtr;
typedef std::unique_ptr<IPDBEnumChildren<ChildType>> MyTypePtr;
virtual ~IPDBEnumChildren() {}
virtual uint32_t getChildCount() const = 0;
virtual ChildTypePtr getChildAtIndex(uint32_t Index) const = 0;
virtual ChildTypePtr getNext() = 0;
virtual void reset() = 0;
virtual MyTypePtr clone() const = 0;
};
}
#endif

llvm/trunk/include/llvm/DebugInfo/PDB/IPDBLineNumber.h

//===- IPDBLineNumber.h - base interface for PDB line no. info ---*- C++-*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_IPDBLINENUMBER_H
#define LLVM_DEBUGINFO_PDB_IPDBLINENUMBER_H
#include "PDBTypes.h"
namespace llvm {
class IPDBLineNumber {
public:
virtual ~IPDBLineNumber();
virtual uint32_t getLineNumber() const = 0;
virtual uint32_t getLineNumberEnd() const = 0;
virtual uint32_t getColumnNumber() const = 0;
virtual uint32_t getColumnNumberEnd() const = 0;
virtual uint32_t getAddressSection() const = 0;
virtual uint32_t getAddressOffset() const = 0;
virtual uint32_t getRelativeVirtualAddress() const = 0;
virtual uint64_t getVirtualAddress() const = 0;
virtual uint32_t getLength() const = 0;
virtual uint32_t getSourceFileId() const = 0;
virtual uint32_t getCompilandId() const = 0;
virtual bool isStatement() const = 0;
};
}
#endif

llvm/trunk/include/llvm/DebugInfo/PDB/IPDBRawSymbol.h

//===- IPDBRawSymbol.h - base interface for PDB symbol types ----*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_IPDBRAWSYMBOL_H
#define LLVM_DEBUGINFO_PDB_IPDBRAWSYMBOL_H
#include <memory>
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/COFF.h"
#include "llvm/Support/raw_ostream.h"
#include "PDBTypes.h"
namespace llvm {
/// IPDBRawSymbol defines an interface used to represent an arbitrary symbol.
/// It exposes a monolithic interface consisting of accessors for the union of
/// all properties that are valid for any symbol type. This interface is then
/// wrapped by a concrete class which exposes only those set of methods valid
/// for this particular symbol type. See PDBSymbol.h for more details.
class IPDBRawSymbol {
public:
virtual ~IPDBRawSymbol();
virtual void dump(llvm::raw_ostream &OS) const = 0;
virtual std::unique_ptr<IPDBEnumSymbols>
findChildren(PDB_SymType Type, StringRef Name,
PDB_NameSearchFlags Flags) const = 0;
virtual std::unique_ptr<IPDBEnumSymbols>
findChildrenByRVA(PDB_SymType Type, StringRef Name, PDB_NameSearchFlags Flags,
uint32_t RVA) const = 0;
virtual std::unique_ptr<IPDBEnumSymbols>
findInlineFramesByRVA(uint32_t RVA) const = 0;
virtual void getDataBytes(llvm::SmallVector<uint8_t, 32> &bytes) const = 0;
virtual PDB_MemberAccess getAccess() const = 0;
virtual uint32_t getAddressOffset() const = 0;
virtual uint32_t getAddressSection() const = 0;
virtual uint32_t getAge() const = 0;
virtual uint32_t getArrayIndexTypeId() const = 0;
virtual uint32_t getBackEndBuild() const = 0;
virtual uint32_t getBackEndMajor() const = 0;
virtual uint32_t getBackEndMinor() const = 0;
virtual uint32_t getBaseDataOffset() const = 0;
virtual uint32_t getBaseDataSlot() const = 0;
virtual uint32_t getBaseSymbolId() const = 0;
virtual PDB_BuiltinType getBuiltinType() const = 0;
virtual uint32_t getBitPosition() const = 0;
virtual PDB_CallingConv getCallingConvention() const = 0;
virtual uint32_t getClassParentId() const = 0;
virtual std::string getCompilerName() const = 0;
virtual uint32_t getCount() const = 0;
virtual uint32_t getCountLiveRanges() const = 0;
virtual uint32_t getFrontEndBuild() const = 0;
virtual uint32_t getFrontEndMajor() const = 0;
virtual uint32_t getFrontEndMinor() const = 0;
virtual PDB_Lang getLanguage() const = 0;
virtual uint32_t getLexicalParentId() const = 0;
virtual std::string getLibraryName() const = 0;
virtual uint32_t getLiveRangeStartAddressOffset() const = 0;
virtual uint32_t getLiveRangeStartAddressSection() const = 0;
virtual uint32_t getLiveRangeStartRelativeVirtualAddress() const = 0;
virtual uint32_t getLocalBasePointerRegisterId() const = 0;
virtual uint32_t getLowerBoundId() const = 0;
virtual uint32_t getMemorySpaceKind() const = 0;
virtual std::string getName() const = 0;
virtual uint32_t getNumberOfAcceleratorPointerTags() const = 0;
virtual uint32_t getNumberOfColumns() const = 0;
virtual uint32_t getNumberOfModifiers() const = 0;
virtual uint32_t getNumberOfRegisterIndices() const = 0;
virtual uint32_t getNumberOfRows() const = 0;
virtual std::string getObjectFileName() const = 0;
virtual uint32_t getOemId() const = 0;
virtual uint32_t getOemSymbolId() const = 0;
virtual uint32_t getOffsetInUdt() const = 0;
virtual PDB_Cpu getPlatform() const = 0;
virtual uint32_t getRank() const = 0;
virtual uint32_t getRegisterId() const = 0;
virtual uint32_t getRegisterType() const = 0;
virtual uint32_t getRelativeVirtualAddress() const = 0;
virtual uint32_t getSamplerSlot() const = 0;
virtual uint32_t getSignature() const = 0;
virtual uint32_t getSizeInUdt() const = 0;
virtual uint32_t getSlot() const = 0;
virtual std::string getSourceFileName() const = 0;
virtual uint32_t getStride() const = 0;
virtual uint32_t getSubTypeId() const = 0;
virtual std::string getSymbolsFileName() const = 0;
virtual uint32_t getSymIndexId() const = 0;
virtual uint32_t getTargetOffset() const = 0;
virtual uint32_t getTargetRelativeVirtualAddress() const = 0;
virtual uint64_t getTargetVirtualAddress() const = 0;
virtual uint32_t getTargetSection() const = 0;
virtual uint32_t getTextureSlot() const = 0;
virtual uint32_t getTimeStamp() const = 0;
virtual uint32_t getToken() const = 0;
virtual uint32_t getTypeId() const = 0;
virtual uint32_t getUavSlot() const = 0;
virtual std::string getUndecoratedName() const = 0;
virtual uint32_t getUnmodifiedTypeId() const = 0;
virtual uint32_t getUpperBoundId() const = 0;
virtual uint32_t getVirtualBaseDispIndex() const = 0;
virtual uint32_t getVirtualBaseOffset() const = 0;
virtual uint32_t getVirtualTableShapeId() const = 0;
virtual PDB_DataKind getDataKind() const = 0;
virtual PDB_SymType getSymTag() const = 0;
virtual PDB_UniqueId getGuid() const = 0;
virtual int32_t getOffset() const = 0;
virtual int32_t getThisAdjust() const = 0;
virtual int32_t getVirtualBasePointerOffset() const = 0;
virtual PDB_LocType getLocationType() const = 0;
virtual COFF::MachineTypes getMachineType() const = 0;
virtual PDB_ThunkOrdinal getThunkOrdinal() const = 0;
virtual uint64_t getLength() const = 0;
virtual uint64_t getLiveRangeLength() const = 0;
virtual uint64_t getVirtualAddress() const = 0;
virtual PDB_UdtType getUdtKind() const = 0;
virtual bool hasConstructor() const = 0;
virtual bool hasCustomCallingConvention() const = 0;
virtual bool hasFarReturn() const = 0;
virtual bool isCode() const = 0;
virtual bool isCompilerGenerated() const = 0;
virtual bool isConstType() const = 0;
virtual bool isEditAndContinueEnabled() const = 0;
virtual bool isFunction() const = 0;
virtual bool getAddressTaken() const = 0;
virtual bool getNoStackOrdering() const = 0;
virtual bool hasAlloca() const = 0;
virtual bool hasAssignmentOperator() const = 0;
virtual bool hasCTypes() const = 0;
virtual bool hasCastOperator() const = 0;
virtual bool hasDebugInfo() const = 0;
virtual bool hasEH() const = 0;
virtual bool hasEHa() const = 0;
virtual bool hasInlAsm() const = 0;
virtual bool hasInlineAttribute() const = 0;
virtual bool hasInterruptReturn() const = 0;
virtual bool hasLongJump() const = 0;
virtual bool hasManagedCode() const = 0;
virtual bool hasNestedTypes() const = 0;
virtual bool hasNoInlineAttribute() const = 0;
virtual bool hasNoReturnAttribute() const = 0;
virtual bool hasOptimizedCodeDebugInfo() const = 0;
virtual bool hasOverloadedOperator() const = 0;
virtual bool hasSEH() const = 0;
virtual bool hasSecurityChecks() const = 0;
virtual bool hasSetJump() const = 0;
virtual bool hasStrictGSCheck() const = 0;
virtual bool isAcceleratorGroupSharedLocal() const = 0;
virtual bool isAcceleratorPointerTagLiveRange() const = 0;
virtual bool isAcceleratorStubFunction() const = 0;
virtual bool isAggregated() const = 0;
virtual bool isIntroVirtualFunction() const = 0;
virtual bool isCVTCIL() const = 0;
virtual bool isConstructorVirtualBase() const = 0;
virtual bool isCxxReturnUdt() const = 0;
virtual bool isDataAligned() const = 0;
virtual bool isHLSLData() const = 0;
virtual bool isHotpatchable() const = 0;
virtual bool isIndirectVirtualBaseClass() const = 0;
virtual bool isInterfaceUdt() const = 0;
virtual bool isIntrinsic() const = 0;
virtual bool isLTCG() const = 0;
virtual bool isLocationControlFlowDependent() const = 0;
virtual bool isMSILNetmodule() const = 0;
virtual bool isMatrixRowMajor() const = 0;
virtual bool isManagedCode() const = 0;
virtual bool isMSILCode() const = 0;
virtual bool isMultipleInheritance() const = 0;
virtual bool isNaked() const = 0;
virtual bool isNested() const = 0;
virtual bool isOptimizedAway() const = 0;
virtual bool isPacked() const = 0;
virtual bool isPointerBasedOnSymbolValue() const = 0;
virtual bool isPointerToDataMember() const = 0;
virtual bool isPointerToMemberFunction() const = 0;
virtual bool isPureVirtual() const = 0;
virtual bool isRValueReference() const = 0;
virtual bool isRefUdt() const = 0;
virtual bool isReference() const = 0;
virtual bool isRestrictedType() const = 0;
virtual bool isReturnValue() const = 0;
virtual bool isSafeBuffers() const = 0;
virtual bool isScoped() const = 0;
virtual bool isSdl() const = 0;
virtual bool isSingleInheritance() const = 0;
virtual bool isSplitted() const = 0;
virtual bool isStatic() const = 0;
virtual bool hasPrivateSymbols() const = 0;
virtual bool isUnalignedType() const = 0;
virtual bool isUnreached() const = 0;
virtual bool isValueUdt() const = 0;
virtual bool isVirtual() const = 0;
virtual bool isVirtualBaseClass() const = 0;
virtual bool isVirtualInheritance() const = 0;
virtual bool isVolatileType() const = 0;
};
} // namespace llvm
#endif

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

//===- IPDBSession.h - base interface for a PDB symbol context --*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_IPDBSESSION_H
#define LLVM_DEBUGINFO_PDB_IPDBSESSION_H
#include <memory>
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolExe;
/// IPDBSession defines an interface used to provide a context for querying
/// debug information from a debug data source (for example, a PDB).
class IPDBSession {
public:
virtual ~IPDBSession();
virtual uint64_t getLoadAddress() const = 0;
virtual void setLoadAddress(uint64_t Address) = 0;
virtual std::unique_ptr<PDBSymbolExe> getGlobalScope() const = 0;
virtual std::unique_ptr<PDBSymbol> getSymbolById() const = 0;
virtual std::unique_ptr<IPDBSourceFile> getSourceFileById() const = 0;
virtual std::unique_ptr<IPDBEnumDataStreams> getDebugStreams() const = 0;
};
}
#endif

llvm/trunk/include/llvm/DebugInfo/PDB/IPDBSourceFile.h

//===- IPDBSourceFile.h - base interface for a PDB source file --*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_IPDBSOURCEFILE_H
#define LLVM_DEBUGINFO_PDB_IPDBSOURCEFILE_H
#include <memory>
#include "PDBTypes.h"
namespace llvm {
/// IPDBSourceFile defines an interface used to represent source files whose
/// information are stored in the PDB.
class IPDBSourceFile {
public:
virtual ~IPDBSourceFile();
virtual std::string getFileName() const = 0;
virtual uint32_t getUniqueId() const = 0;
virtual std::string getChecksum() const = 0;
virtual PDB_Checksum getChecksumType() const = 0;
virtual std::unique_ptr<IPDBEnumCompilands> getCompilands() const = 0;
};
}
#endif

llvm/trunk/include/llvm/DebugInfo/PDB/PDB.h

//===- PDB.h - base header file for creating a PDB reader -------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDB_H
#define LLVM_DEBUGINFO_PDB_PDB_H
#include <memory>
#include "PDBTypes.h"
namespace llvm {
class StringRef;
std::unique_ptr<IPDBSession> createPDBReader(PDB_ReaderType Type,
StringRef Path);
}
#endif

llvm/trunk/include/llvm/DebugInfo/PDB/PDBSymbol.h

//===- PDBSymbol.h - base class for user-facing symbol types -----*- C++-*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_IPDBSYMBOL_H
#define LLVM_DEBUGINFO_PDB_IPDBSYMBOL_H
#include <memory>
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Support/Casting.h"
#include "IPDBRawSymbol.h"
#include "PDBTypes.h"
#define FORWARD_SYMBOL_METHOD(MethodName) \
auto MethodName() const->decltype(RawSymbol->MethodName()) { \
return RawSymbol->MethodName(); \
}
namespace llvm {
class IPDBRawSymbol;
/// PDBSymbol defines the base of the inheritance hierarchy for concrete symbol
/// types (e.g. functions, executables, vtables, etc). All concrete symbol
/// types inherit from PDBSymbol and expose the exact set of methods that are
/// valid for that particular symbol type, as described in the Microsoft
/// reference "Lexical and Class Hierarchy of Symbol Types":
/// https://msdn.microsoft.com/en-us/library/370hs6k4.aspx
class PDBSymbol {
protected:
PDBSymbol(std::unique_ptr<IPDBRawSymbol> Symbol);
public:
static std::unique_ptr<PDBSymbol>
create(std::unique_ptr<IPDBRawSymbol> Symbol);
virtual ~PDBSymbol();
/// Dumps the contents of a symbol a raw_ostream. By default this will just
/// call dump() on the underlying RawSymbol, which allows us to discover
/// unknown properties, but individual implementations of PDBSymbol may
/// override the behavior to only dump known fields.
virtual void dump(llvm::raw_ostream &OS) const;
PDB_SymType getSymTag() const;
std::unique_ptr<IPDBEnumSymbols>
findChildren(PDB_SymType Type, StringRef Name,
PDB_NameSearchFlags Flags) const;
std::unique_ptr<IPDBEnumSymbols> findChildrenByRVA(PDB_SymType Type,
StringRef Name,
PDB_NameSearchFlags Flags,
uint32_t RVA) const;
std::unique_ptr<IPDBEnumSymbols> findInlineFramesByRVA(uint32_t RVA) const;
protected:
const std::unique_ptr<IPDBRawSymbol> RawSymbol;
};
} // namespace llvm
#endif

llvm/trunk/include/llvm/DebugInfo/PDB/PDBSymbolAnnotation.h

//===- PDBSymbolAnnotation.h - Accessors for querying PDB annotations ---*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLANNOTATION_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLANNOTATION_H
#include <string>
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolAnnotation : public PDBSymbol {
public:
PDBSymbolAnnotation(std::unique_ptr<IPDBRawSymbol> AnnotationSymbol);
FORWARD_SYMBOL_METHOD(getAddressOffset)
FORWARD_SYMBOL_METHOD(getAddressSection)
FORWARD_SYMBOL_METHOD(getDataKind)
FORWARD_SYMBOL_METHOD(getRelativeVirtualAddress)
FORWARD_SYMBOL_METHOD(getSymIndexId)
// FORWARD_SYMBOL_METHOD(getValue)
FORWARD_SYMBOL_METHOD(getVirtualAddress)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::Annotation;
}
};
}
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLANNOTATION_H

llvm/trunk/include/llvm/DebugInfo/PDB/PDBSymbolBlock.h

//===- PDBSymbolBlock.h - Accessors for querying PDB blocks -------------*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLBLOCK_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLBLOCK_H
#include <string>
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolBlock : public PDBSymbol {
public:
PDBSymbolBlock(std::unique_ptr<IPDBRawSymbol> BlockSymbol);
FORWARD_SYMBOL_METHOD(getAddressOffset)
FORWARD_SYMBOL_METHOD(getAddressSection)
FORWARD_SYMBOL_METHOD(getLength)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getLocationType)
FORWARD_SYMBOL_METHOD(getName)
FORWARD_SYMBOL_METHOD(getRelativeVirtualAddress)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(getVirtualAddress)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::Block;
}
};
}
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLBLOCK_H

llvm/trunk/include/llvm/DebugInfo/PDB/PDBSymbolCompiland.h

//===- PDBSymbolCompiland.h - Accessors for querying PDB compilands -----*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLCOMPILAND_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLCOMPILAND_H
#include <string>
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolCompiland : public PDBSymbol {
public:
PDBSymbolCompiland(std::unique_ptr<IPDBRawSymbol> CompilandSymbol);
FORWARD_SYMBOL_METHOD(isEditAndContinueEnabled)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getLibraryName)
FORWARD_SYMBOL_METHOD(getName)
FORWARD_SYMBOL_METHOD(getSourceFileName)
FORWARD_SYMBOL_METHOD(getSymIndexId)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::Compiland;
}
};
}
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLCOMPILAND_H

llvm/trunk/include/llvm/DebugInfo/PDB/PDBSymbolCompilandDetails.h

//===- PDBSymbolCompilandDetails.h - PDB compiland details ------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLCOMPILANDDETAILS_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLCOMPILANDDETAILS_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolCompilandDetails : public PDBSymbol {
public:
PDBSymbolCompilandDetails(std::unique_ptr<IPDBRawSymbol> DetailsSymbol);
FORWARD_SYMBOL_METHOD(getBackEndBuild)
FORWARD_SYMBOL_METHOD(getBackEndMajor)
FORWARD_SYMBOL_METHOD(getBackEndMinor)
FORWARD_SYMBOL_METHOD(getCompilerName)
FORWARD_SYMBOL_METHOD(isEditAndContinueEnabled)
FORWARD_SYMBOL_METHOD(getFrontEndBuild)
FORWARD_SYMBOL_METHOD(getFrontEndMajor)
FORWARD_SYMBOL_METHOD(getFrontEndMinor)
FORWARD_SYMBOL_METHOD(hasDebugInfo)
FORWARD_SYMBOL_METHOD(hasManagedCode)
FORWARD_SYMBOL_METHOD(hasSecurityChecks)
FORWARD_SYMBOL_METHOD(isCVTCIL)
FORWARD_SYMBOL_METHOD(isDataAligned)
FORWARD_SYMBOL_METHOD(isHotpatchable)
FORWARD_SYMBOL_METHOD(isLTCG)
FORWARD_SYMBOL_METHOD(isMSILNetmodule)
FORWARD_SYMBOL_METHOD(getLanguage)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getPlatform)
FORWARD_SYMBOL_METHOD(getSymIndexId)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::CompilandDetails;
}
};
}; // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBFUNCTION_H

llvm/trunk/include/llvm/DebugInfo/PDB/PDBSymbolCompilandEnv.h

//===- PDBSymbolCompilandEnv.h - compiland environment variables *- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLCOMPILANDENV_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLCOMPILANDENV_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolCompilandEnv : public PDBSymbol {
public:
PDBSymbolCompilandEnv(std::unique_ptr<IPDBRawSymbol> CompilandEnvSymbol);
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getName)
FORWARD_SYMBOL_METHOD(getSymIndexId)
std::string getValue() const;
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::CompilandEnv;
}
};
}; // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLCOMPILANDENV_H

llvm/trunk/include/llvm/DebugInfo/PDB/PDBSymbolCustom.h

//===- PDBSymbolCustom.h - compiler-specific types --------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLCUSTOM_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLCUSTOM_H
#include "llvm/ADT/SmallVector.h"
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
/// PDBSymbolCustom represents symbols that are compiler-specific and do not
/// fit anywhere else in the lexical hierarchy.
/// https://msdn.microsoft.com/en-us/library/d88sf09h.aspx
class PDBSymbolCustom : public PDBSymbol {
public:
PDBSymbolCustom(std::unique_ptr<IPDBRawSymbol> CustomSymbol);
void getDataBytes(llvm::SmallVector<uint8_t, 32> &bytes);
FORWARD_SYMBOL_METHOD(getSymIndexId)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::Custom;
}
};
}; // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLCUSTOM_H

llvm/trunk/include/llvm/DebugInfo/PDB/PDBSymbolData.h

//===- PDBSymbolData.h - PDB data (e.g. variable) accessors -----*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLDATA_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLDATA_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolData : public PDBSymbol {
public:
PDBSymbolData(std::unique_ptr<IPDBRawSymbol> DataSymbol);
FORWARD_SYMBOL_METHOD(getAccess)
FORWARD_SYMBOL_METHOD(getAddressOffset)
FORWARD_SYMBOL_METHOD(getAddressSection)
FORWARD_SYMBOL_METHOD(getAddressTaken)
FORWARD_SYMBOL_METHOD(getBitPosition)
FORWARD_SYMBOL_METHOD(getClassParentId)
FORWARD_SYMBOL_METHOD(isCompilerGenerated)
FORWARD_SYMBOL_METHOD(isConstType)
FORWARD_SYMBOL_METHOD(getDataKind)
FORWARD_SYMBOL_METHOD(isAggregated)
FORWARD_SYMBOL_METHOD(isSplitted)
FORWARD_SYMBOL_METHOD(getLength)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getLocationType)
FORWARD_SYMBOL_METHOD(getName)
FORWARD_SYMBOL_METHOD(getOffset)
FORWARD_SYMBOL_METHOD(getRegisterId)
FORWARD_SYMBOL_METHOD(getRelativeVirtualAddress)
FORWARD_SYMBOL_METHOD(getSlot)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(getToken)
FORWARD_SYMBOL_METHOD(getTypeId)
FORWARD_SYMBOL_METHOD(isUnalignedType)
// FORWARD_SYMBOL_METHOD(getValue)
FORWARD_SYMBOL_METHOD(getVirtualAddress)
FORWARD_SYMBOL_METHOD(isVolatileType)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::Data;
}
};
}; // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLDATA_H

llvm/trunk/include/llvm/DebugInfo/PDB/PDBSymbolExe.h

//===- PDBSymbolExe.h - Accessors for querying executables in a PDB ----*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLEXE_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLEXE_H
#include <string>
#include "llvm/Support/COFF.h"
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolExe : public PDBSymbol {
public:
PDBSymbolExe(std::unique_ptr<IPDBRawSymbol> ExeSymbol);
FORWARD_SYMBOL_METHOD(getAge)
FORWARD_SYMBOL_METHOD(getGuid)
FORWARD_SYMBOL_METHOD(hasCTypes)
FORWARD_SYMBOL_METHOD(hasPrivateSymbols)
FORWARD_SYMBOL_METHOD(getMachineType)
FORWARD_SYMBOL_METHOD(getName)
FORWARD_SYMBOL_METHOD(getSignature)
FORWARD_SYMBOL_METHOD(getSymbolsFileName)
FORWARD_SYMBOL_METHOD(getSymIndexId)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::Exe;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLEXE_H

llvm/trunk/include/llvm/DebugInfo/PDB/PDBSymbolFunc.h

//===- PDBSymbolFunc.h - class representing a function instance -*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLFUNC_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLFUNC_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolFunc : public PDBSymbol {
public:
PDBSymbolFunc(std::unique_ptr<IPDBRawSymbol> FuncSymbol);
FORWARD_SYMBOL_METHOD(getAccess)
FORWARD_SYMBOL_METHOD(getAddressOffset)
FORWARD_SYMBOL_METHOD(getAddressSection)
FORWARD_SYMBOL_METHOD(getClassParentId)
FORWARD_SYMBOL_METHOD(isConstType)
FORWARD_SYMBOL_METHOD(hasCustomCallingConvention)
FORWARD_SYMBOL_METHOD(hasFarReturn)
FORWARD_SYMBOL_METHOD(hasAlloca)
FORWARD_SYMBOL_METHOD(hasEH)
FORWARD_SYMBOL_METHOD(hasEHa)
FORWARD_SYMBOL_METHOD(hasInlAsm)
FORWARD_SYMBOL_METHOD(hasLongJump)
FORWARD_SYMBOL_METHOD(hasSEH)
FORWARD_SYMBOL_METHOD(hasSecurityChecks)
FORWARD_SYMBOL_METHOD(hasSetJump)
FORWARD_SYMBOL_METHOD(hasInterruptReturn)
FORWARD_SYMBOL_METHOD(isIntroVirtualFunction)
FORWARD_SYMBOL_METHOD(hasInlineAttribute)
FORWARD_SYMBOL_METHOD(isNaked)
FORWARD_SYMBOL_METHOD(isStatic)
FORWARD_SYMBOL_METHOD(getLength)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getLocationType)
FORWARD_SYMBOL_METHOD(getName)
FORWARD_SYMBOL_METHOD(hasNoInlineAttribute)
FORWARD_SYMBOL_METHOD(hasNoReturnAttribute)
FORWARD_SYMBOL_METHOD(isUnreached)
FORWARD_SYMBOL_METHOD(getNoStackOrdering)
FORWARD_SYMBOL_METHOD(hasOptimizedCodeDebugInfo)
FORWARD_SYMBOL_METHOD(isPureVirtual)
FORWARD_SYMBOL_METHOD(getRelativeVirtualAddress)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(getToken)
FORWARD_SYMBOL_METHOD(getTypeId)
FORWARD_SYMBOL_METHOD(isUnalignedType)
FORWARD_SYMBOL_METHOD(getUndecoratedName)
FORWARD_SYMBOL_METHOD(isVirtual)
FORWARD_SYMBOL_METHOD(getVirtualAddress)
FORWARD_SYMBOL_METHOD(getVirtualBaseOffset)
FORWARD_SYMBOL_METHOD(isVolatileType)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::Function;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLFUNC_H

llvm/trunk/include/llvm/DebugInfo/PDB/PDBSymbolFuncDebugEnd.h

//===- PDBSymbolFuncDebugEnd.h - function end bounds info -------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLFUNCDEBUGEND_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLFUNCDEBUGEND_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolFuncDebugEnd : public PDBSymbol {
public:
PDBSymbolFuncDebugEnd(std::unique_ptr<IPDBRawSymbol> FuncDebugEndSymbol);
FORWARD_SYMBOL_METHOD(getAddressOffset)
FORWARD_SYMBOL_METHOD(getAddressSection)
FORWARD_SYMBOL_METHOD(hasCustomCallingConvention)
FORWARD_SYMBOL_METHOD(hasFarReturn)
FORWARD_SYMBOL_METHOD(hasInterruptReturn)
FORWARD_SYMBOL_METHOD(isStatic)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getLocationType)
FORWARD_SYMBOL_METHOD(hasNoInlineAttribute)
FORWARD_SYMBOL_METHOD(hasNoReturnAttribute)
FORWARD_SYMBOL_METHOD(isUnreached)
FORWARD_SYMBOL_METHOD(getOffset)
FORWARD_SYMBOL_METHOD(hasOptimizedCodeDebugInfo)
FORWARD_SYMBOL_METHOD(getRelativeVirtualAddress)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(getVirtualAddress)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::FuncDebugEnd;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLFUNCDEBUGEND_H

llvm/trunk/include/llvm/DebugInfo/PDB/PDBSymbolFuncDebugStart.h

//===- PDBSymbolFuncDebugStart.h - function start bounds info ---*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLFUNCDEBUGSTART_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLFUNCDEBUGSTART_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolFuncDebugStart : public PDBSymbol {
public:
PDBSymbolFuncDebugStart(std::unique_ptr<IPDBRawSymbol> FuncDebugStartSymbol);
FORWARD_SYMBOL_METHOD(getAddressOffset)
FORWARD_SYMBOL_METHOD(getAddressSection)
FORWARD_SYMBOL_METHOD(hasCustomCallingConvention)
FORWARD_SYMBOL_METHOD(hasFarReturn)
FORWARD_SYMBOL_METHOD(hasInterruptReturn)
FORWARD_SYMBOL_METHOD(isStatic)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getLocationType)
FORWARD_SYMBOL_METHOD(hasNoInlineAttribute)
FORWARD_SYMBOL_METHOD(hasNoReturnAttribute)
FORWARD_SYMBOL_METHOD(isUnreached)
FORWARD_SYMBOL_METHOD(getOffset)
FORWARD_SYMBOL_METHOD(hasOptimizedCodeDebugInfo)
FORWARD_SYMBOL_METHOD(getRelativeVirtualAddress)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(getVirtualAddress)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::FuncDebugStart;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLFUNCDEBUGSTART_H

llvm/trunk/include/llvm/DebugInfo/PDB/PDBSymbolLabel.h

//===- PDBSymbolLabel.h - label info ----------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLLABEL_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLLABEL_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolLabel : public PDBSymbol {
public:
PDBSymbolLabel(std::unique_ptr<IPDBRawSymbol> LabelSymbol);
FORWARD_SYMBOL_METHOD(getAddressOffset)
FORWARD_SYMBOL_METHOD(getAddressSection)
FORWARD_SYMBOL_METHOD(hasCustomCallingConvention)
FORWARD_SYMBOL_METHOD(hasFarReturn)
FORWARD_SYMBOL_METHOD(hasInterruptReturn)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getLocationType)
FORWARD_SYMBOL_METHOD(getName)
FORWARD_SYMBOL_METHOD(hasNoInlineAttribute)
FORWARD_SYMBOL_METHOD(hasNoReturnAttribute)
FORWARD_SYMBOL_METHOD(isUnreached)
FORWARD_SYMBOL_METHOD(getOffset)
FORWARD_SYMBOL_METHOD(hasOptimizedCodeDebugInfo)
FORWARD_SYMBOL_METHOD(getRelativeVirtualAddress)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(getVirtualAddress)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::Label;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLLABEL_H

llvm/trunk/include/llvm/DebugInfo/PDB/PDBSymbolPublicSymbol.h

//===- PDBSymbolPublicSymbol.h - public symbol info -------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLPUBLICSYMBOL_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLPUBLICSYMBOL_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolPublicSymbol : public PDBSymbol {
public:
PDBSymbolPublicSymbol(std::unique_ptr<IPDBRawSymbol> PublicSymbol);
FORWARD_SYMBOL_METHOD(getAddressOffset)
FORWARD_SYMBOL_METHOD(getAddressSection)
FORWARD_SYMBOL_METHOD(isCode)
FORWARD_SYMBOL_METHOD(isFunction)
FORWARD_SYMBOL_METHOD(getLength)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getLocationType)
FORWARD_SYMBOL_METHOD(isManagedCode)
FORWARD_SYMBOL_METHOD(isMSILCode)
FORWARD_SYMBOL_METHOD(getName)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(getRelativeVirtualAddress)
FORWARD_SYMBOL_METHOD(getVirtualAddress)
FORWARD_SYMBOL_METHOD(getUndecoratedName)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::PublicSymbol;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLPUBLICSYMBOL_H

llvm/trunk/include/llvm/DebugInfo/PDB/PDBSymbolThunk.h

//===- PDBSymbolThunk.h - Support for querying PDB thunks ---------------*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLTHUNK_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLTHUNK_H
#include <string>
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolThunk : public PDBSymbol {
public:
PDBSymbolThunk(std::unique_ptr<IPDBRawSymbol> ThunkSymbol);
FORWARD_SYMBOL_METHOD(getAccess)
FORWARD_SYMBOL_METHOD(getAddressOffset)
FORWARD_SYMBOL_METHOD(getAddressSection)
FORWARD_SYMBOL_METHOD(getClassParentId)
FORWARD_SYMBOL_METHOD(isConstType)
FORWARD_SYMBOL_METHOD(isIntroVirtualFunction)
FORWARD_SYMBOL_METHOD(isStatic)
FORWARD_SYMBOL_METHOD(getLength)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getName)
FORWARD_SYMBOL_METHOD(isPureVirtual)
FORWARD_SYMBOL_METHOD(getRelativeVirtualAddress)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(getTargetOffset)
FORWARD_SYMBOL_METHOD(getTargetRelativeVirtualAddress)
FORWARD_SYMBOL_METHOD(getTargetVirtualAddress)
FORWARD_SYMBOL_METHOD(getTargetSection)
FORWARD_SYMBOL_METHOD(getThunkOrdinal)
FORWARD_SYMBOL_METHOD(getTypeId)
FORWARD_SYMBOL_METHOD(isUnalignedType)
FORWARD_SYMBOL_METHOD(isVirtual)
FORWARD_SYMBOL_METHOD(getVirtualAddress)
FORWARD_SYMBOL_METHOD(getVirtualBaseOffset)
FORWARD_SYMBOL_METHOD(isVolatileType)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::Thunk;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTHUNK_H

llvm/trunk/include/llvm/DebugInfo/PDB/PDBSymbolTypeArray.h

//===- PDBSymbolTypeArray.h - array type information ------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEARRAY_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEARRAY_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolTypeArray : public PDBSymbol {
public:
PDBSymbolTypeArray(std::unique_ptr<IPDBRawSymbol> ArrayTypeSymbol);
FORWARD_SYMBOL_METHOD(getArrayIndexTypeId)
FORWARD_SYMBOL_METHOD(isConstType)
FORWARD_SYMBOL_METHOD(getCount)
FORWARD_SYMBOL_METHOD(getLength)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getRank)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(getTypeId)
FORWARD_SYMBOL_METHOD(isUnalignedType)
FORWARD_SYMBOL_METHOD(isVolatileType)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::ArrayType;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEARRAY_H

llvm/trunk/include/llvm/DebugInfo/PDB/PDBSymbolTypeBaseClass.h

//===- PDBSymbolTypeBaseClass.h - base class type information ---*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEBASECLASS_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEBASECLASS_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolTypeBaseClass : public PDBSymbol {
public:
PDBSymbolTypeBaseClass(std::unique_ptr<IPDBRawSymbol> BaseClassTypeSymbol);
FORWARD_SYMBOL_METHOD(getAccess)
FORWARD_SYMBOL_METHOD(getClassParentId)
FORWARD_SYMBOL_METHOD(hasConstructor)
FORWARD_SYMBOL_METHOD(isConstType)
FORWARD_SYMBOL_METHOD(hasAssignmentOperator)
FORWARD_SYMBOL_METHOD(hasCastOperator)
FORWARD_SYMBOL_METHOD(hasNestedTypes)
FORWARD_SYMBOL_METHOD(isIndirectVirtualBaseClass)
FORWARD_SYMBOL_METHOD(getLength)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getName)
FORWARD_SYMBOL_METHOD(isNested)
FORWARD_SYMBOL_METHOD(getOffset)
FORWARD_SYMBOL_METHOD(hasOverloadedOperator)
FORWARD_SYMBOL_METHOD(isPacked)
FORWARD_SYMBOL_METHOD(isScoped)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(getTypeId)
FORWARD_SYMBOL_METHOD(getUdtKind)
FORWARD_SYMBOL_METHOD(isUnalignedType)
FORWARD_SYMBOL_METHOD(isVirtualBaseClass)
FORWARD_SYMBOL_METHOD(getVirtualBaseDispIndex)
FORWARD_SYMBOL_METHOD(getVirtualBasePointerOffset)
// FORWARD_SYMBOL_METHOD(getVirtualBaseTableType)
FORWARD_SYMBOL_METHOD(getVirtualTableShapeId)
FORWARD_SYMBOL_METHOD(isVolatileType)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::BaseClass;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEBASECLASS_H

llvm/trunk/include/llvm/DebugInfo/PDB/PDBSymbolTypeBuiltin.h

//===- PDBSymbolTypeBuiltin.h - builtin type information --------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEBUILTIN_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEBUILTIN_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolTypeBuiltin : public PDBSymbol {
public:
PDBSymbolTypeBuiltin(std::unique_ptr<IPDBRawSymbol> BuiltinTypeSymbol);
FORWARD_SYMBOL_METHOD(getBuiltinType)
FORWARD_SYMBOL_METHOD(isConstType)
FORWARD_SYMBOL_METHOD(getLength)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(isUnalignedType)
FORWARD_SYMBOL_METHOD(isVolatileType)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::BuiltinType;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEBUILTIN_H

llvm/trunk/include/llvm/DebugInfo/PDB/PDBSymbolTypeCustom.h

//===- PDBSymbolTypeCustom.h - custom compiler type information -*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPECUSTOM_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPECUSTOM_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolTypeCustom : public PDBSymbol {
public:
PDBSymbolTypeCustom(std::unique_ptr<IPDBRawSymbol> CustomTypeSymbol);
FORWARD_SYMBOL_METHOD(getOemId)
FORWARD_SYMBOL_METHOD(getOemSymbolId)
FORWARD_SYMBOL_METHOD(getSymIndexId)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::CustomType;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPECUSTOM_H

llvm/trunk/include/llvm/DebugInfo/PDB/PDBSymbolTypeDimension.h

//===- PDBSymbolTypeDimension.h - array dimension type info -----*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEDIMENSION_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEDIMENSION_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolTypeDimension : public PDBSymbol {
public:
PDBSymbolTypeDimension(std::unique_ptr<IPDBRawSymbol> DimensionTypeSymbol);
FORWARD_SYMBOL_METHOD(getLowerBoundId)
FORWARD_SYMBOL_METHOD(getUpperBoundId)
FORWARD_SYMBOL_METHOD(getSymIndexId)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::Dimension;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEDIMENSION_H

llvm/trunk/include/llvm/DebugInfo/PDB/PDBSymbolTypeEnum.h

//===- PDBSymbolTypeEnum.h - enum type info ---------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEENUM_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEENUM_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolTypeEnum : public PDBSymbol {
public:
PDBSymbolTypeEnum(std::unique_ptr<IPDBRawSymbol> EnumTypeSymbol);
FORWARD_SYMBOL_METHOD(getBuiltinType)
FORWARD_SYMBOL_METHOD(getClassParentId)
FORWARD_SYMBOL_METHOD(hasConstructor)
FORWARD_SYMBOL_METHOD(isConstType)
FORWARD_SYMBOL_METHOD(hasAssignmentOperator)
FORWARD_SYMBOL_METHOD(hasCastOperator)
FORWARD_SYMBOL_METHOD(hasNestedTypes)
FORWARD_SYMBOL_METHOD(getLength)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getName)
FORWARD_SYMBOL_METHOD(isNested)
FORWARD_SYMBOL_METHOD(hasOverloadedOperator)
FORWARD_SYMBOL_METHOD(isPacked)
FORWARD_SYMBOL_METHOD(isScoped)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(getTypeId)
FORWARD_SYMBOL_METHOD(isUnalignedType)
FORWARD_SYMBOL_METHOD(isVolatileType)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::Enum;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEENUM_H

llvm/trunk/include/llvm/DebugInfo/PDB/PDBSymbolTypeFriend.h

//===- PDBSymbolTypeFriend.h - friend type info -----------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEFRIEND_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEFRIEND_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolTypeFriend : public PDBSymbol {
public:
PDBSymbolTypeFriend(std::unique_ptr<IPDBRawSymbol> FriendTypeSymbol);
FORWARD_SYMBOL_METHOD(getClassParentId)
FORWARD_SYMBOL_METHOD(getName)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(getTypeId)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::Friend;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEFRIEND_H

llvm/trunk/include/llvm/DebugInfo/PDB/PDBSymbolTypeFunctionArg.h

//===- PDBSymbolTypeFunctionArg.h - function arg type info ------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEFUNCTIONARG_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEFUNCTIONARG_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolTypeFunctionArg : public PDBSymbol {
public:
PDBSymbolTypeFunctionArg(std::unique_ptr<IPDBRawSymbol> FuncArgTypeSymbol);
FORWARD_SYMBOL_METHOD(getClassParentId)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(getTypeId)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::FunctionArg;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEFUNCTIONARG_H

llvm/trunk/include/llvm/DebugInfo/PDB/PDBSymbolTypeFunctionSig.h

//===- PDBSymbolTypeFunctionSig.h - function signature type info *- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEFUNCTIONSIG_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEFUNCTIONSIG_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolTypeFunctionSig : public PDBSymbol {
public:
PDBSymbolTypeFunctionSig(std::unique_ptr<IPDBRawSymbol> FuncSigTypeSymbol);
FORWARD_SYMBOL_METHOD(getCallingConvention)
FORWARD_SYMBOL_METHOD(getClassParentId)
FORWARD_SYMBOL_METHOD(isConstType)
FORWARD_SYMBOL_METHOD(getCount)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
// FORWARD_SYMBOL_METHOD(getObjectPointerType)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(getThisAdjust)
FORWARD_SYMBOL_METHOD(getTypeId)
FORWARD_SYMBOL_METHOD(isUnalignedType)
FORWARD_SYMBOL_METHOD(isVolatileType)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::FunctionSig;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEFUNCTIONSIG_H

llvm/trunk/include/llvm/DebugInfo/PDB/PDBSymbolTypeManaged.h

//===- PDBSymbolTypeManaged.h - managed type info ---------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEMANAGED_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEMANAGED_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolTypeManaged : public PDBSymbol {
public:
PDBSymbolTypeManaged(std::unique_ptr<IPDBRawSymbol> ManagedTypeSymbol);
FORWARD_SYMBOL_METHOD(getName)
FORWARD_SYMBOL_METHOD(getSymIndexId)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::ManagedType;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEMANAGED_H

llvm/trunk/include/llvm/DebugInfo/PDB/PDBSymbolTypePointer.h

//===- PDBSymbolTypePointer.h - pointer type info ---------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEPOINTER_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEPOINTER_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolTypePointer : public PDBSymbol {
public:
PDBSymbolTypePointer(std::unique_ptr<IPDBRawSymbol> PointerTypeSymbol);
FORWARD_SYMBOL_METHOD(isConstType)
FORWARD_SYMBOL_METHOD(getLength)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(isReference)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(getTypeId)
FORWARD_SYMBOL_METHOD(isUnalignedType)
FORWARD_SYMBOL_METHOD(isVolatileType)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::PointerType;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEPOINTER_H

llvm/trunk/include/llvm/DebugInfo/PDB/PDBSymbolTypeTypedef.h

//===- PDBSymbolTypeTypedef.h - typedef type info ---------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPETYPEDEF_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPETYPEDEF_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolTypeTypedef : public PDBSymbol {
public:
PDBSymbolTypeTypedef(std::unique_ptr<IPDBRawSymbol> TypedefSymbol);
FORWARD_SYMBOL_METHOD(getBuiltinType)
FORWARD_SYMBOL_METHOD(getClassParentId)
FORWARD_SYMBOL_METHOD(hasConstructor)
FORWARD_SYMBOL_METHOD(isConstType)
FORWARD_SYMBOL_METHOD(hasAssignmentOperator)
FORWARD_SYMBOL_METHOD(hasCastOperator)
FORWARD_SYMBOL_METHOD(hasNestedTypes)
FORWARD_SYMBOL_METHOD(getLength)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getName)
FORWARD_SYMBOL_METHOD(isNested)
FORWARD_SYMBOL_METHOD(hasOverloadedOperator)
FORWARD_SYMBOL_METHOD(isPacked)
FORWARD_SYMBOL_METHOD(isReference)
FORWARD_SYMBOL_METHOD(isScoped)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(getTypeId)
FORWARD_SYMBOL_METHOD(getUdtKind)
FORWARD_SYMBOL_METHOD(isUnalignedType)
FORWARD_SYMBOL_METHOD(getVirtualTableShapeId)
FORWARD_SYMBOL_METHOD(isVolatileType)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::Typedef;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPETYPEDEF_H

llvm/trunk/include/llvm/DebugInfo/PDB/PDBSymbolTypeUDT.h

//===- PDBSymbolTypeUDT.h - UDT type info -----------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEUDT_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEUDT_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolTypeUDT : public PDBSymbol {
public:
PDBSymbolTypeUDT(std::unique_ptr<IPDBRawSymbol> UDTSymbol);
FORWARD_SYMBOL_METHOD(getClassParentId)
FORWARD_SYMBOL_METHOD(hasConstructor)
FORWARD_SYMBOL_METHOD(isConstType)
FORWARD_SYMBOL_METHOD(hasAssignmentOperator)
FORWARD_SYMBOL_METHOD(hasCastOperator)
FORWARD_SYMBOL_METHOD(hasNestedTypes)
FORWARD_SYMBOL_METHOD(getLength)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getName)
FORWARD_SYMBOL_METHOD(isNested)
FORWARD_SYMBOL_METHOD(hasOverloadedOperator)
FORWARD_SYMBOL_METHOD(isPacked)
FORWARD_SYMBOL_METHOD(isScoped)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(getUdtKind)
FORWARD_SYMBOL_METHOD(isUnalignedType)
FORWARD_SYMBOL_METHOD(getVirtualTableShapeId)
FORWARD_SYMBOL_METHOD(isVolatileType)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::UDT;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEUDT_H

llvm/trunk/include/llvm/DebugInfo/PDB/PDBSymbolTypeVTable.h

//===- PDBSymbolTypeVTable.h - VTable type info -----------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEVTABLE_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEVTABLE_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolTypeVTable : public PDBSymbol {
public:
PDBSymbolTypeVTable(std::unique_ptr<IPDBRawSymbol> VtblSymbol);
FORWARD_SYMBOL_METHOD(getClassParentId)
FORWARD_SYMBOL_METHOD(isConstType)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(getTypeId)
FORWARD_SYMBOL_METHOD(isUnalignedType)
FORWARD_SYMBOL_METHOD(isVolatileType)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::VTable;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEVTABLE_H

llvm/trunk/include/llvm/DebugInfo/PDB/PDBSymbolTypeVTableShape.h

//===- PDBSymbolTypeVTableShape.h - VTable shape info -----------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEVTABLESHAPE_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEVTABLESHAPE_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolTypeVTableShape : public PDBSymbol {
public:
PDBSymbolTypeVTableShape(std::unique_ptr<IPDBRawSymbol> VtblShapeSymbol);
FORWARD_SYMBOL_METHOD(isConstType)
FORWARD_SYMBOL_METHOD(getCount)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(isUnalignedType)
FORWARD_SYMBOL_METHOD(isVolatileType)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::VTableShape;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEVTABLESHAPE_H

llvm/trunk/include/llvm/DebugInfo/PDB/PDBSymbolUnknown.h

//===- PDBSymbolUnknown.h - unknown symbol type -----------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLUNKNOWN_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLUNKNOWN_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolUnknown : public PDBSymbol {
public:
PDBSymbolUnknown(std::unique_ptr<IPDBRawSymbol> UnknownSymbol);
static bool classof(const PDBSymbol *S) {
return (S->getSymTag() == PDB_SymType::None ||
S->getSymTag() >= PDB_SymType::Max);
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLUNKNOWN_H

llvm/trunk/include/llvm/DebugInfo/PDB/PDBSymbolUsingNamespace.h

//===- PDBSymbolUsingNamespace.h - using namespace info ---------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLUSINGNAMESPACE_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLUSINGNAMESPACE_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolUsingNamespace : public PDBSymbol {
public:
PDBSymbolUsingNamespace(std::unique_ptr<IPDBRawSymbol> UsingSymbol);
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getName)
FORWARD_SYMBOL_METHOD(getSymIndexId)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::UsingNamespace;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLUSINGNAMESPACE_H

llvm/trunk/include/llvm/DebugInfo/PDB/PDBTypes.h

//===- PDBTypes.h - Defines enums for various fields contained in PDB ---*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBTYPES_H
#define LLVM_DEBUGINFO_PDB_PDBTYPES_H
#include <stdint.h>
namespace llvm {
class PDBSymbol;
class PDBSymbolCompiland;
class PDBSymbolFunc;
class PDBSymbolExe;
class IPDBDataStream;
template <class T> class IPDBEnumChildren;
class IPDBRawSymbol;
class IPDBSession;
class IPDBSourceFile;
typedef IPDBEnumChildren<IPDBRawSymbol> IPDBEnumSymbols;
typedef IPDBEnumChildren<IPDBSourceFile> IPDBEnumSourceFiles;
typedef IPDBEnumChildren<IPDBDataStream> IPDBEnumDataStreams;
typedef IPDBEnumChildren<PDBSymbolCompiland> IPDBEnumCompilands;
class PDBSymbolExe;
class PDBSymbolCompiland;
class PDBSymbolCompilandDetails;
class PDBSymbolCompilandEnv;
class PDBSymbolFunc;
class PDBSymbolBlock;
class PDBSymbolData;
class PDBSymbolAnnotation;
class PDBSymbolLabel;
class PDBSymbolPublicSymbol;
class PDBSymbolTypeUDT;
class PDBSymbolTypeEnum;
class PDBSymbolTypeFunctionSig;
class PDBSymbolTypePointer;
class PDBSymbolTypeArray;
class PDBSymbolTypeBuiltin;
class PDBSymbolTypeTypedef;
class PDBSymbolTypeBaseClass;
class PDBSymbolTypeFriend;
class PDBSymbolTypeFunctionArg;
class PDBSymbolFuncDebugStart;
class PDBSymbolFuncDebugEnd;
class PDBSymbolUsingNamespace;
class PDBSymbolTypeVTableShape;
class PDBSymbolTypeVTable;
class PDBSymbolCustom;
class PDBSymbolThunk;
class PDBSymbolTypeCustom;
class PDBSymbolTypeManaged;
class PDBSymbolTypeDimension;
class PDBSymbolUnknown;
/// Specifies which PDB reader implementation is to be used. Only a value
/// of PDB_ReaderType::DIA is supported.
enum class PDB_ReaderType {
SystemDefault = 0,
#if defined(_MSC_VER)
DIA = 1,
#endif
};
/// Defines a 128-bit unique identifier. This maps to a GUID on Windows, but
/// is abstracted here for the purposes of non-Windows platforms that don't have
/// the GUID structure defined.
struct PDB_UniqueId {
uint64_t HighPart;
uint64_t LowPart;
};
/// An enumeration indicating the type of data contained in this table.
enum class PDB_TableType {
Symbols,
SourceFiles,
LineNumbers,
SectionContribs,
Segments,
InjectedSources,
FrameData
};
/// Defines flags used for enumerating child symbols. This corresponds to the
/// NameSearchOptions enumeration which is documented here:
/// https://msdn.microsoft.com/en-us/library/yat28ads.aspx
enum PDB_NameSearchFlags {
NS_Default = 0x0,
NS_CaseSensitive = 0x1,
NS_CaseInsensitive = 0x2,
NS_FileNameExtMatch = 0x4,
NS_Regex = 0x8,
NS_UndecoratedName = 0x10
};
/// Specifies the hash algorithm that a source file from a PDB was hashed with.
/// This corresponds to the CV_SourceChksum_t enumeration and are documented
/// here: https://msdn.microsoft.com/en-us/library/e96az21x.aspx
enum class PDB_Checksum { None = 0, MD5 = 1, SHA1 = 2 };
/// These values correspond to the CV_CPU_TYPE_e enumeration, and are documented
/// here: https://msdn.microsoft.com/en-us/library/b2fc64ek.aspx
enum class PDB_Cpu {
Intel8080 = 0x0,
Intel8086 = 0x1,
Intel80286 = 0x2,
Intel80386 = 0x3,
Intel80486 = 0x4,
Pentium = 0x5,
PentiumPro = 0x6,
Pentium3 = 0x7,
MIPS = 0x10,
MIPS16 = 0x11,
MIPS32 = 0x12,
MIPS64 = 0x13,
MIPSI = 0x14,
MIPSII = 0x15,
MIPSIII = 0x16,
MIPSIV = 0x17,
MIPSV = 0x18,
M68000 = 0x20,
M68010 = 0x21,
M68020 = 0x22,
M68030 = 0x23,
M68040 = 0x24,
Alpha = 0x30,
Alpha21164 = 0x31,
Alpha21164A = 0x32,
Alpha21264 = 0x33,
Alpha21364 = 0x34,
PPC601 = 0x40,
PPC603 = 0x41,
PPC604 = 0x42,
PPC620 = 0x43,
PPCFP = 0x44,
PPCBE = 0x45,
SH3 = 0x50,
SH3E = 0x51,
SH3DSP = 0x52,
SH4 = 0x53,
SHMedia = 0x54,
ARM3 = 0x60,
ARM4 = 0x61,
ARM4T = 0x62,
ARM5 = 0x63,
ARM5T = 0x64,
ARM6 = 0x65,
ARM_XMAC = 0x66,
ARM_WMMX = 0x67,
ARM7 = 0x68,
Omni = 0x70,
Ia64 = 0x80,
Ia64_2 = 0x81,
CEE = 0x90,
AM33 = 0xa0,
M32R = 0xb0,
TriCore = 0xc0,
X64 = 0xd0,
EBC = 0xe0,
Thumb = 0xf0,
ARMNT = 0xf4,
D3D11_Shader = 0x100,
};
/// These values correspond to the CV_call_e enumeration, and are documented
/// at the following locations:
/// https://msdn.microsoft.com/en-us/library/b2fc64ek.aspx
/// https://msdn.microsoft.com/en-us/library/windows/desktop/ms680207(v=vs.85).aspx
///
enum class PDB_CallingConv {
NearCdecl = 0x00,
FarCdecl = 0x01,
NearPascal = 0x02,
FarPascal = 0x03,
NearFastcall = 0x04,
FarFastcall = 0x05,
Skipped = 0x06,
NearStdcall = 0x07,
FarStdcall = 0x08,
NearSyscall = 0x09,
FarSyscall = 0x0a,
Thiscall = 0x0b,
MipsCall = 0x0c,
Generic = 0x0d,
Alphacall = 0x0e,
Ppccall = 0x0f,
SuperHCall = 0x10,
Armcall = 0x11,
AM33call = 0x12,
Tricall = 0x13,
Sh5call = 0x14,
M32R = 0x15,
Clrcall = 0x16,
Inline = 0x17,
NearVectorcall = 0x18,
Reserved = 0x19,
};
/// These values correspond to the CV_CFL_LANG enumeration, and are documented
/// here: https://msdn.microsoft.com/en-us/library/bw3aekw6.aspx
enum class PDB_Lang {
C = 0x00,
Cpp = 0x01,
Fortran = 0x02,
Masm = 0x03,
Pascal = 0x04,
Basic = 0x05,
Cobol = 0x06,
Link = 0x07,
Cvtres = 0x08,
Cvtpgd = 0x09,
CSharp = 0x0a,
VB = 0x0b,
ILAsm = 0x0c,
Java = 0x0d,
JScript = 0x0e,
MSIL = 0x0f,
HLSL = 0x10
};
/// These values correspond to the DataKind enumeration, and are documented
/// here: https://msdn.microsoft.com/en-us/library/b2x2t313.aspx
enum class PDB_DataKind {
Unknown,
Local,
StaticLocal,
Param,
ObjectPtr,
FileStatic,
Global,
Member,
StaticMember,
Constant
};
/// These values correspond to the SymTagEnum enumeration, and are documented
/// here: https://msdn.microsoft.com/en-us/library/bkedss5f.aspx
enum class PDB_SymType {
None,
Exe,
Compiland,
CompilandDetails,
CompilandEnv,
Function,
Block,
Data,
Annotation,
Label,
PublicSymbol,
UDT,
Enum,
FunctionSig,
PointerType,
ArrayType,
BuiltinType,
Typedef,
BaseClass,
Friend,
FunctionArg,
FuncDebugStart,
FuncDebugEnd,
UsingNamespace,
VTableShape,
VTable,
Custom,
Thunk,
CustomType,
ManagedType,
Dimension,
Max
};
/// These values correspond to the LocationType enumeration, and are documented
/// here: https://msdn.microsoft.com/en-us/library/f57kaez3.aspx
enum class PDB_LocType {
Null,
Static,
TLS,
RegRel,
ThisRel,
Enregistered,
BitField,
Slot,
IlRel,
MetaData,
Constant,
Max
};
/// These values correspond to the THUNK_ORDINAL enumeration, and are documented
/// here: https://msdn.microsoft.com/en-us/library/dh0k8hft.aspx
enum class PDB_ThunkOrdinal {
Standard,
ThisAdjustor,
Vcall,
Pcode,
UnknownLoad,
TrampIncremental,
BranchIsland
};
/// These values correspond to the UdtKind enumeration, and are documented
/// here: https://msdn.microsoft.com/en-us/library/wcstk66t.aspx
enum class PDB_UdtType { Struct, Class, Union, Interface };
/// These values correspond to the StackFrameTypeEnum enumeration, and are
/// documented here: https://msdn.microsoft.com/en-us/library/bc5207xw.aspx.
enum class PDB_StackFrameType { FPO, KernelTrap, KernelTSS, EBP, FrameData };
/// These values correspond to the StackFrameTypeEnum enumeration, and are
/// documented here: https://msdn.microsoft.com/en-us/library/bc5207xw.aspx.
enum class PDB_MemoryType { Code, Data, Stack, HeapCode };
/// These values correspond to the Basictype enumeration, and are documented
/// here: https://msdn.microsoft.com/en-us/library/4szdtzc3.aspx
enum class PDB_BuiltinType {
None = 0,
Void = 1,
Char = 2,
WCharT = 3,
Int = 6,
UInt = 7,
Float = 8,
BCD = 9,
Bool = 10,
Long = 13,
ULong = 14,
Currency = 25,
Date = 26,
Variant = 27,
Complex = 28,
Bitfield = 29,
BSTR = 30,
HResult = 31
};
enum class PDB_MemberAccess { Private = 1, Protected = 2, Public = 3 };
} // namespace llvm
#endif

llvm/trunk/lib/DebugInfo/CMakeLists.txt

add_subdirectory(DWARF) add_subdirectory(DWARF)
No newline at end of file if (MSVC)
add_subdirectory(PDB)
endif()
No newline at end of file

llvm/trunk/lib/DebugInfo/LLVMBuild.txt

Show All 10 Lines
; ;
; For more information on the LLVMBuild system, please see: ; For more information on the LLVMBuild system, please see:
; ;
; http://llvm.org/docs/LLVMBuild.html ; http://llvm.org/docs/LLVMBuild.html
; ;
;===------------------------------------------------------------------------===; ;===------------------------------------------------------------------------===;
[common] [common]
subdirectories = DWARF subdirectories = DWARF PDB
[component_0] [component_0]
type = Group type = Group
name = DebugInfo name = DebugInfo
parent = $ROOT parent = $ROOT

llvm/trunk/lib/DebugInfo/PDB/CMakeLists.txt

add_llvm_library(LLVMDebugInfoPDB
PDB.cpp
PDBInterfaceAnchors.cpp
PDBSymbol.cpp
PDBSymbolCompilandEnv.cpp
PDBSymbolCustom.cpp
)

llvm/trunk/lib/DebugInfo/PDB/LLVMBuild.txt

;===- ./lib/DebugInfo/PDB/LLVMBuild.txt ------------------------*- Conf -*--===;
;
; The LLVM Compiler Infrastructure
;
; This file is distributed under the University of Illinois Open Source
; License. See LICENSE.TXT for details.
;
;===------------------------------------------------------------------------===;
;
; This is an LLVMBuild description file for the components in this subdirectory.
;
; For more information on the LLVMBuild system, please see:
;
; http://llvm.org/docs/LLVMBuild.html
;
;===------------------------------------------------------------------------===;
[component_0]
type = Library
name = DebugInfoPDB
parent = DebugInfo
required_libraries = Support

llvm/trunk/lib/DebugInfo/PDB/PDB.cpp

//===- PDB.cpp - base header file for creating a PDB reader -----*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "llvm/ADT/StringRef.h"
#include "llvm/DebugInfo/PDB/PDB.h"
#include "llvm/DebugInfo/PDB/IPDBSession.h"
using namespace llvm;
std::unique_ptr<IPDBSession> llvm::createPDBReader(PDB_ReaderType Type,
StringRef Path) {
// Create the correct concrete instance type based on the value of Type.
return nullptr;
}

llvm/trunk/lib/DebugInfo/PDB/PDBInterfaceAnchors.cpp

//===- PDBInterfaceAnchors.h - defines class anchor funcions ----*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// Class anchors are necessary per the LLVM Coding style guide, to ensure that
// the vtable is only generated in this object file, and not in every object
// file that incldues the corresponding header.
//===----------------------------------------------------------------------===//
#include "llvm/DebugInfo/PDB/IPDBDataStream.h"
#include "llvm/DebugInfo/PDB/IPDBLineNumber.h"
#include "llvm/DebugInfo/PDB/IPDBSession.h"
#include "llvm/DebugInfo/PDB/IPDBSourceFile.h"
#include "llvm/DebugInfo/PDB/IPDBRawSymbol.h"
#include "llvm/DebugInfo/PDB/PDBSymbolAnnotation.h"
#include "llvm/DebugInfo/PDB/PDBSymbolBlock.h"
#include "llvm/DebugInfo/PDB/PDBSymbolCompiland.h"
#include "llvm/DebugInfo/PDB/PDBSymbolCompilandDetails.h"
#include "llvm/DebugInfo/PDB/PDBSymbolCompilandEnv.h"
#include "llvm/DebugInfo/PDB/PDBSymbolCustom.h"
#include "llvm/DebugInfo/PDB/PDBSymbolData.h"
#include "llvm/DebugInfo/PDB/PDBSymbolExe.h"
#include "llvm/DebugInfo/PDB/PDBSymbolFunc.h"
#include "llvm/DebugInfo/PDB/PDBSymbolFuncDebugEnd.h"
#include "llvm/DebugInfo/PDB/PDBSymbolFuncDebugStart.h"
#include "llvm/DebugInfo/PDB/PDBSymbolLabel.h"
#include "llvm/DebugInfo/PDB/PDBSymbolPublicSymbol.h"
#include "llvm/DebugInfo/PDB/PDBSymbolThunk.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeArray.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeBaseClass.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeBuiltin.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeCustom.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeDimension.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeEnum.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeFriend.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeFunctionArg.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeFunctionSig.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeManaged.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypePointer.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeTypedef.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeUDT.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeVTable.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeVTableShape.h"
#include "llvm/DebugInfo/PDB/PDBSymbolUnknown.h"
#include "llvm/DebugInfo/PDB/PDBSymbolUsingNamespace.h"
using namespace llvm;
IPDBSession::~IPDBSession() {}
IPDBDataStream::~IPDBDataStream() {}
IPDBRawSymbol::~IPDBRawSymbol() {}
IPDBSourceFile::~IPDBSourceFile() {}
IPDBLineNumber::~IPDBLineNumber() {}
// All of the concrete symbol types have their methods declared inline through
// the use of a forwarding macro, so the constructor should be declared out of
// line to get the vtable in this file.
#define FORWARD_SYMBOL_CONSTRUCTOR(ClassName) \
ClassName::ClassName(std::unique_ptr<IPDBRawSymbol> Symbol) \
: PDBSymbol(std::move(Symbol)) {}
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolAnnotation)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolBlock)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolCompiland)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolCompilandDetails)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolCompilandEnv)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolCustom)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolData)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolExe)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolFunc)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolFuncDebugEnd)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolFuncDebugStart)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolLabel)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolPublicSymbol)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolThunk)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolTypeArray)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolTypeBaseClass)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolTypeBuiltin)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolTypeCustom)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolTypeDimension)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolTypeEnum)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolTypeFriend)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolTypeFunctionArg)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolTypeFunctionSig)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolTypeManaged)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolTypePointer)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolTypeTypedef)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolTypeUDT)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolTypeVTable)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolTypeVTableShape)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolUnknown)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolUsingNamespace)

llvm/trunk/lib/DebugInfo/PDB/PDBSymbol.cpp

//===- PDBSymbol.cpp - base class for user-facing symbol types --*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include <memory>
#include <utility>
#include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
#include "llvm/DebugInfo/PDB/IPDBRawSymbol.h"
#include "llvm/DebugInfo/PDB/PDBSymbol.h"
#include "llvm/DebugInfo/PDB/PDBSymbolAnnotation.h"
#include "llvm/DebugInfo/PDB/PDBSymbolBlock.h"
#include "llvm/DebugInfo/PDB/PDBSymbolCompiland.h"
#include "llvm/DebugInfo/PDB/PDBSymbolCompilandDetails.h"
#include "llvm/DebugInfo/PDB/PDBSymbolCompilandEnv.h"
#include "llvm/DebugInfo/PDB/PDBSymbolCustom.h"
#include "llvm/DebugInfo/PDB/PDBSymbolData.h"
#include "llvm/DebugInfo/PDB/PDBSymbolExe.h"
#include "llvm/DebugInfo/PDB/PDBSymbolFunc.h"
#include "llvm/DebugInfo/PDB/PDBSymbolFuncDebugEnd.h"
#include "llvm/DebugInfo/PDB/PDBSymbolFuncDebugStart.h"
#include "llvm/DebugInfo/PDB/PDBSymbolLabel.h"
#include "llvm/DebugInfo/PDB/PDBSymbolPublicSymbol.h"
#include "llvm/DebugInfo/PDB/PDBSymbolThunk.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeArray.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeBaseClass.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeBuiltin.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeCustom.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeDimension.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeEnum.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeFriend.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeFunctionArg.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeFunctionSig.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeManaged.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypePointer.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeTypedef.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeUDT.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeVTable.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeVTableShape.h"
#include "llvm/DebugInfo/PDB/PDBSymbolUnknown.h"
#include "llvm/DebugInfo/PDB/PDBSymbolUsingNamespace.h"
using namespace llvm;
PDBSymbol::PDBSymbol(std::unique_ptr<IPDBRawSymbol> Symbol)
: RawSymbol(std::move(Symbol)) {}
PDBSymbol::~PDBSymbol() {}
#define FACTORY_SYMTAG_CASE(Tag, Type) \
case PDB_SymType::Tag: \
return std::unique_ptr<PDBSymbol>(new Type(std::move(Symbol)));
std::unique_ptr<PDBSymbol>
PDBSymbol::create(std::unique_ptr<IPDBRawSymbol> Symbol) {
switch (Symbol->getSymTag()) {
FACTORY_SYMTAG_CASE(Exe, PDBSymbolExe)
FACTORY_SYMTAG_CASE(Compiland, PDBSymbolCompiland)
FACTORY_SYMTAG_CASE(CompilandDetails, PDBSymbolCompilandDetails)
FACTORY_SYMTAG_CASE(CompilandEnv, PDBSymbolCompilandEnv)
FACTORY_SYMTAG_CASE(Function, PDBSymbolFunc)
FACTORY_SYMTAG_CASE(Block, PDBSymbolBlock)
FACTORY_SYMTAG_CASE(Data, PDBSymbolData)
FACTORY_SYMTAG_CASE(Annotation, PDBSymbolAnnotation)
FACTORY_SYMTAG_CASE(Label, PDBSymbolLabel)
FACTORY_SYMTAG_CASE(PublicSymbol, PDBSymbolPublicSymbol)
FACTORY_SYMTAG_CASE(UDT, PDBSymbolTypeUDT)
FACTORY_SYMTAG_CASE(Enum, PDBSymbolTypeEnum)
FACTORY_SYMTAG_CASE(FunctionSig, PDBSymbolTypeFunctionSig)
FACTORY_SYMTAG_CASE(PointerType, PDBSymbolTypePointer)
FACTORY_SYMTAG_CASE(ArrayType, PDBSymbolTypeArray)
FACTORY_SYMTAG_CASE(BuiltinType, PDBSymbolTypeBuiltin)
FACTORY_SYMTAG_CASE(Typedef, PDBSymbolTypeTypedef)
FACTORY_SYMTAG_CASE(BaseClass, PDBSymbolTypeBaseClass)
FACTORY_SYMTAG_CASE(Friend, PDBSymbolTypeFriend)
FACTORY_SYMTAG_CASE(FunctionArg, PDBSymbolTypeFunctionArg)
FACTORY_SYMTAG_CASE(FuncDebugStart, PDBSymbolFuncDebugStart)
FACTORY_SYMTAG_CASE(FuncDebugEnd, PDBSymbolFuncDebugEnd)
FACTORY_SYMTAG_CASE(UsingNamespace, PDBSymbolUsingNamespace)
FACTORY_SYMTAG_CASE(VTableShape, PDBSymbolTypeVTableShape)
FACTORY_SYMTAG_CASE(VTable, PDBSymbolTypeVTable)
FACTORY_SYMTAG_CASE(Custom, PDBSymbolCustom)
FACTORY_SYMTAG_CASE(Thunk, PDBSymbolThunk)
FACTORY_SYMTAG_CASE(CustomType, PDBSymbolTypeCustom)
FACTORY_SYMTAG_CASE(ManagedType, PDBSymbolTypeManaged)
FACTORY_SYMTAG_CASE(Dimension, PDBSymbolTypeDimension)
default:
return std::unique_ptr<PDBSymbol>(new PDBSymbolUnknown(std::move(Symbol)));
}
}
void PDBSymbol::dump(llvm::raw_ostream &OS) const { RawSymbol->dump(OS); }
PDB_SymType PDBSymbol::getSymTag() const { return RawSymbol->getSymTag(); }
std::unique_ptr<IPDBEnumSymbols>
PDBSymbol::findChildren(PDB_SymType Type, StringRef Name,
PDB_NameSearchFlags Flags) const {
return RawSymbol->findChildren(Type, Name, Flags);
}
std::unique_ptr<IPDBEnumSymbols>
PDBSymbol::findChildrenByRVA(PDB_SymType Type, StringRef Name,
PDB_NameSearchFlags Flags, uint32_t RVA) const {
return RawSymbol->findChildrenByRVA(Type, Name, Flags, RVA);
}
std::unique_ptr<IPDBEnumSymbols>
PDBSymbol::findInlineFramesByRVA(uint32_t RVA) const {
return RawSymbol->findInlineFramesByRVA(RVA);
}

llvm/trunk/lib/DebugInfo/PDB/PDBSymbolCompilandEnv.cpp

//===- PDBSymbolCompilandEnv.cpp - compiland env variables ------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include <utility>
#include "llvm/DebugInfo/PDB/IPDBRawSymbol.h"
#include "llvm/DebugInfo/PDB/PDBSymbol.h"
#include "llvm/DebugInfo/PDB/PDBSymbolCompilandEnv.h"
using namespace llvm;
std::string PDBSymbolCompilandEnv::getValue() const {
// call RawSymbol->getValue() and convert the result to an std::string.
return std::string();
}

llvm/trunk/lib/DebugInfo/PDB/PDBSymbolCustom.cpp

//===- PDBSymbolCustom.cpp - compiler-specific types ------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include <utility>
#include "llvm/DebugInfo/PDB/IPDBRawSymbol.h"
#include "llvm/DebugInfo/PDB/PDBSymbol.h"
#include "llvm/DebugInfo/PDB/PDBSymbolCustom.h"
using namespace llvm;
void PDBSymbolCustom::getDataBytes(llvm::SmallVector<uint8_t, 32> &bytes) {
RawSymbol->getDataBytes(bytes);
}

llvm/trunk/unittests/DebugInfo/CMakeLists.txt

set(LLVM_LINK_COMPONENTS set(LLVM_LINK_COMPONENTS
DebugInfoDWARF DebugInfoDWARF
) )
set(DebugInfoSources set(DebugInfoSources
DWARFFormValueTest.cpp DWARFFormValueTest.cpp
) )
add_llvm_unittest(DebugInfoTests add_llvm_unittest(DebugInfoTests
${DebugInfoSources} ${DebugInfoSources}
) )
add_subdirectory(PDB)
No newline at end of file

llvm/trunk/unittests/DebugInfo/PDB/CMakeLists.txt

set(LLVM_LINK_COMPONENTS
DebugInfoPDB
)
set(DebugInfoPDBSources
PDBApiTest.cpp
)
add_llvm_unittest(DebugInfoPDBTests
${DebugInfoPDBSources}
)

llvm/trunk/unittests/DebugInfo/PDB/Makefile

##===- unittests/DebugInfo/PDB/Makefile -------------------*- Makefile -*-===##
#
# The LLVM Compiler Infrastructure
#
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
#
##===----------------------------------------------------------------------===##
LEVEL = ../..
TESTNAME = DebugInfoPDB
LINK_COMPONENTS := DebugInfoPDB object support
include $(LEVEL)/Makefile.config
include $(LLVM_SRC_ROOT)/unittests/Makefile.unittest

llvm/trunk/unittests/DebugInfo/PDB/PDBApiTest.cpp

//===- llvm/unittest/DebugInfo/PDB/PDBApiTest.cpp -------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include <hash_map>
#include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
#include "llvm/DebugInfo/PDB/IPDBRawSymbol.h"
#include "llvm/DebugInfo/PDB/PDBSymbol.h"
#include "llvm/DebugInfo/PDB/PDBSymbolAnnotation.h"
#include "llvm/DebugInfo/PDB/PDBSymbolBlock.h"
#include "llvm/DebugInfo/PDB/PDBSymbolCompiland.h"
#include "llvm/DebugInfo/PDB/PDBSymbolCompilandDetails.h"
#include "llvm/DebugInfo/PDB/PDBSymbolCompilandEnv.h"
#include "llvm/DebugInfo/PDB/PDBSymbolCustom.h"
#include "llvm/DebugInfo/PDB/PDBSymbolData.h"
#include "llvm/DebugInfo/PDB/PDBSymbolExe.h"
#include "llvm/DebugInfo/PDB/PDBSymbolFunc.h"
#include "llvm/DebugInfo/PDB/PDBSymbolFuncDebugEnd.h"
#include "llvm/DebugInfo/PDB/PDBSymbolFuncDebugStart.h"
#include "llvm/DebugInfo/PDB/PDBSymbolLabel.h"
#include "llvm/DebugInfo/PDB/PDBSymbolPublicSymbol.h"
#include "llvm/DebugInfo/PDB/PDBSymbolThunk.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeArray.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeBaseClass.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeBuiltin.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeCustom.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeDimension.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeEnum.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeFriend.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeFunctionArg.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeFunctionSig.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeManaged.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypePointer.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeTypedef.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeUDT.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeVTable.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeVTableShape.h"
#include "llvm/DebugInfo/PDB/PDBSymbolUnknown.h"
#include "llvm/DebugInfo/PDB/PDBSymbolUsingNamespace.h"
#include "llvm/DebugInfo/PDB/PDBTypes.h"
#include "gtest/gtest.h"
using namespace llvm;
namespace {
#define MOCK_SYMBOL_ACCESSOR(Func) \
auto Func() const->decltype(((IPDBRawSymbol *)nullptr)->Func()) override { \
typedef decltype(IPDBRawSymbol::Func()) ReturnType; \
return ReturnType(); \
}
class MockRawSymbol : public IPDBRawSymbol {
public:
MockRawSymbol(PDB_SymType SymType) : Type(SymType) {}
virtual void dump(llvm::raw_ostream &OS) const {}
virtual std::unique_ptr<IPDBEnumSymbols>
findChildren(PDB_SymType Type, StringRef Name,
PDB_NameSearchFlags Flags) const {
return nullptr;
}
virtual std::unique_ptr<IPDBEnumSymbols>
findChildrenByRVA(PDB_SymType Type, StringRef Name, PDB_NameSearchFlags Flags,
uint32_t RVA) const {
return nullptr;
}
virtual std::unique_ptr<IPDBEnumSymbols>
findInlineFramesByRVA(uint32_t RVA) const {
return nullptr;
}
virtual void getDataBytes(llvm::SmallVector<uint8_t, 32> &bytes) const {}
PDB_SymType getSymTag() const override { return Type; }
MOCK_SYMBOL_ACCESSOR(getAccess)
MOCK_SYMBOL_ACCESSOR(getAddressOffset)
MOCK_SYMBOL_ACCESSOR(getAddressSection)
MOCK_SYMBOL_ACCESSOR(getAge)
MOCK_SYMBOL_ACCESSOR(getArrayIndexTypeId)
MOCK_SYMBOL_ACCESSOR(getBackEndBuild)
MOCK_SYMBOL_ACCESSOR(getBackEndMajor)
MOCK_SYMBOL_ACCESSOR(getBackEndMinor)
MOCK_SYMBOL_ACCESSOR(getBaseDataOffset)
MOCK_SYMBOL_ACCESSOR(getBaseDataSlot)
MOCK_SYMBOL_ACCESSOR(getBaseSymbolId)
MOCK_SYMBOL_ACCESSOR(getBuiltinType)
MOCK_SYMBOL_ACCESSOR(getBitPosition)
MOCK_SYMBOL_ACCESSOR(getCallingConvention)
MOCK_SYMBOL_ACCESSOR(getClassParentId)
MOCK_SYMBOL_ACCESSOR(getCompilerName)
MOCK_SYMBOL_ACCESSOR(getCount)
MOCK_SYMBOL_ACCESSOR(getCountLiveRanges)
MOCK_SYMBOL_ACCESSOR(getFrontEndBuild)
MOCK_SYMBOL_ACCESSOR(getFrontEndMajor)
MOCK_SYMBOL_ACCESSOR(getFrontEndMinor)
MOCK_SYMBOL_ACCESSOR(getLanguage)
MOCK_SYMBOL_ACCESSOR(getLexicalParentId)
MOCK_SYMBOL_ACCESSOR(getLibraryName)
MOCK_SYMBOL_ACCESSOR(getLiveRangeStartAddressOffset)
MOCK_SYMBOL_ACCESSOR(getLiveRangeStartAddressSection)
MOCK_SYMBOL_ACCESSOR(getLiveRangeStartRelativeVirtualAddress)
MOCK_SYMBOL_ACCESSOR(getLocalBasePointerRegisterId)
MOCK_SYMBOL_ACCESSOR(getLowerBoundId)
MOCK_SYMBOL_ACCESSOR(getMemorySpaceKind)
MOCK_SYMBOL_ACCESSOR(getName)
MOCK_SYMBOL_ACCESSOR(getNumberOfAcceleratorPointerTags)
MOCK_SYMBOL_ACCESSOR(getNumberOfColumns)
MOCK_SYMBOL_ACCESSOR(getNumberOfModifiers)
MOCK_SYMBOL_ACCESSOR(getNumberOfRegisterIndices)
MOCK_SYMBOL_ACCESSOR(getNumberOfRows)
MOCK_SYMBOL_ACCESSOR(getObjectFileName)
MOCK_SYMBOL_ACCESSOR(getOemId)
MOCK_SYMBOL_ACCESSOR(getOemSymbolId)
MOCK_SYMBOL_ACCESSOR(getOffsetInUdt)
MOCK_SYMBOL_ACCESSOR(getPlatform)
MOCK_SYMBOL_ACCESSOR(getRank)
MOCK_SYMBOL_ACCESSOR(getRegisterId)
MOCK_SYMBOL_ACCESSOR(getRegisterType)
MOCK_SYMBOL_ACCESSOR(getRelativeVirtualAddress)
MOCK_SYMBOL_ACCESSOR(getSamplerSlot)
MOCK_SYMBOL_ACCESSOR(getSignature)
MOCK_SYMBOL_ACCESSOR(getSizeInUdt)
MOCK_SYMBOL_ACCESSOR(getSlot)
MOCK_SYMBOL_ACCESSOR(getSourceFileName)
MOCK_SYMBOL_ACCESSOR(getStride)
MOCK_SYMBOL_ACCESSOR(getSubTypeId)
MOCK_SYMBOL_ACCESSOR(getSymbolsFileName)
MOCK_SYMBOL_ACCESSOR(getSymIndexId)
MOCK_SYMBOL_ACCESSOR(getTargetOffset)
MOCK_SYMBOL_ACCESSOR(getTargetRelativeVirtualAddress)
MOCK_SYMBOL_ACCESSOR(getTargetVirtualAddress)
MOCK_SYMBOL_ACCESSOR(getTargetSection)
MOCK_SYMBOL_ACCESSOR(getTextureSlot)
MOCK_SYMBOL_ACCESSOR(getTimeStamp)
MOCK_SYMBOL_ACCESSOR(getToken)
MOCK_SYMBOL_ACCESSOR(getTypeId)
MOCK_SYMBOL_ACCESSOR(getUavSlot)
MOCK_SYMBOL_ACCESSOR(getUndecoratedName)
MOCK_SYMBOL_ACCESSOR(getUnmodifiedTypeId)
MOCK_SYMBOL_ACCESSOR(getUpperBoundId)
MOCK_SYMBOL_ACCESSOR(getVirtualBaseDispIndex)
MOCK_SYMBOL_ACCESSOR(getVirtualBaseOffset)
MOCK_SYMBOL_ACCESSOR(getVirtualTableShapeId)
MOCK_SYMBOL_ACCESSOR(getDataKind)
MOCK_SYMBOL_ACCESSOR(getGuid)
MOCK_SYMBOL_ACCESSOR(getOffset)
MOCK_SYMBOL_ACCESSOR(getThisAdjust)
MOCK_SYMBOL_ACCESSOR(getVirtualBasePointerOffset)
MOCK_SYMBOL_ACCESSOR(getLocationType)
MOCK_SYMBOL_ACCESSOR(getMachineType)
MOCK_SYMBOL_ACCESSOR(getThunkOrdinal)
MOCK_SYMBOL_ACCESSOR(getLength)
MOCK_SYMBOL_ACCESSOR(getLiveRangeLength)
MOCK_SYMBOL_ACCESSOR(getVirtualAddress)
MOCK_SYMBOL_ACCESSOR(getUdtKind)
MOCK_SYMBOL_ACCESSOR(hasConstructor)
MOCK_SYMBOL_ACCESSOR(hasCustomCallingConvention)
MOCK_SYMBOL_ACCESSOR(hasFarReturn)
MOCK_SYMBOL_ACCESSOR(isCode)
MOCK_SYMBOL_ACCESSOR(isCompilerGenerated)
MOCK_SYMBOL_ACCESSOR(isConstType)
MOCK_SYMBOL_ACCESSOR(isEditAndContinueEnabled)
MOCK_SYMBOL_ACCESSOR(isFunction)
MOCK_SYMBOL_ACCESSOR(getAddressTaken)
MOCK_SYMBOL_ACCESSOR(getNoStackOrdering)
MOCK_SYMBOL_ACCESSOR(hasAlloca)
MOCK_SYMBOL_ACCESSOR(hasAssignmentOperator)
MOCK_SYMBOL_ACCESSOR(hasCTypes)
MOCK_SYMBOL_ACCESSOR(hasCastOperator)
MOCK_SYMBOL_ACCESSOR(hasDebugInfo)
MOCK_SYMBOL_ACCESSOR(hasEH)
MOCK_SYMBOL_ACCESSOR(hasEHa)
MOCK_SYMBOL_ACCESSOR(hasInlAsm)
MOCK_SYMBOL_ACCESSOR(hasInlineAttribute)
MOCK_SYMBOL_ACCESSOR(hasInterruptReturn)
MOCK_SYMBOL_ACCESSOR(hasLongJump)
MOCK_SYMBOL_ACCESSOR(hasManagedCode)
MOCK_SYMBOL_ACCESSOR(hasNestedTypes)
MOCK_SYMBOL_ACCESSOR(hasNoInlineAttribute)
MOCK_SYMBOL_ACCESSOR(hasNoReturnAttribute)
MOCK_SYMBOL_ACCESSOR(hasOptimizedCodeDebugInfo)
MOCK_SYMBOL_ACCESSOR(hasOverloadedOperator)
MOCK_SYMBOL_ACCESSOR(hasSEH)
MOCK_SYMBOL_ACCESSOR(hasSecurityChecks)
MOCK_SYMBOL_ACCESSOR(hasSetJump)
MOCK_SYMBOL_ACCESSOR(hasStrictGSCheck)
MOCK_SYMBOL_ACCESSOR(isAcceleratorGroupSharedLocal)
MOCK_SYMBOL_ACCESSOR(isAcceleratorPointerTagLiveRange)
MOCK_SYMBOL_ACCESSOR(isAcceleratorStubFunction)
MOCK_SYMBOL_ACCESSOR(isAggregated)
MOCK_SYMBOL_ACCESSOR(isIntroVirtualFunction)
MOCK_SYMBOL_ACCESSOR(isCVTCIL)
MOCK_SYMBOL_ACCESSOR(isConstructorVirtualBase)
MOCK_SYMBOL_ACCESSOR(isCxxReturnUdt)
MOCK_SYMBOL_ACCESSOR(isDataAligned)
MOCK_SYMBOL_ACCESSOR(isHLSLData)
MOCK_SYMBOL_ACCESSOR(isHotpatchable)
MOCK_SYMBOL_ACCESSOR(isIndirectVirtualBaseClass)
MOCK_SYMBOL_ACCESSOR(isInterfaceUdt)
MOCK_SYMBOL_ACCESSOR(isIntrinsic)
MOCK_SYMBOL_ACCESSOR(isLTCG)
MOCK_SYMBOL_ACCESSOR(isLocationControlFlowDependent)
MOCK_SYMBOL_ACCESSOR(isMSILNetmodule)
MOCK_SYMBOL_ACCESSOR(isMatrixRowMajor)
MOCK_SYMBOL_ACCESSOR(isManagedCode)
MOCK_SYMBOL_ACCESSOR(isMSILCode)
MOCK_SYMBOL_ACCESSOR(isMultipleInheritance)
MOCK_SYMBOL_ACCESSOR(isNaked)
MOCK_SYMBOL_ACCESSOR(isNested)
MOCK_SYMBOL_ACCESSOR(isOptimizedAway)
MOCK_SYMBOL_ACCESSOR(isPacked)
MOCK_SYMBOL_ACCESSOR(isPointerBasedOnSymbolValue)
MOCK_SYMBOL_ACCESSOR(isPointerToDataMember)
MOCK_SYMBOL_ACCESSOR(isPointerToMemberFunction)
MOCK_SYMBOL_ACCESSOR(isPureVirtual)
MOCK_SYMBOL_ACCESSOR(isRValueReference)
MOCK_SYMBOL_ACCESSOR(isRefUdt)
MOCK_SYMBOL_ACCESSOR(isReference)
MOCK_SYMBOL_ACCESSOR(isRestrictedType)
MOCK_SYMBOL_ACCESSOR(isReturnValue)
MOCK_SYMBOL_ACCESSOR(isSafeBuffers)
MOCK_SYMBOL_ACCESSOR(isScoped)
MOCK_SYMBOL_ACCESSOR(isSdl)
MOCK_SYMBOL_ACCESSOR(isSingleInheritance)
MOCK_SYMBOL_ACCESSOR(isSplitted)
MOCK_SYMBOL_ACCESSOR(isStatic)
MOCK_SYMBOL_ACCESSOR(hasPrivateSymbols)
MOCK_SYMBOL_ACCESSOR(isUnalignedType)
MOCK_SYMBOL_ACCESSOR(isUnreached)
MOCK_SYMBOL_ACCESSOR(isValueUdt)
MOCK_SYMBOL_ACCESSOR(isVirtual)
MOCK_SYMBOL_ACCESSOR(isVirtualBaseClass)
MOCK_SYMBOL_ACCESSOR(isVirtualInheritance)
MOCK_SYMBOL_ACCESSOR(isVolatileType)
private:
PDB_SymType Type;
};
class PDBApiTest : public testing::Test {
public:
std::hash_map<PDB_SymType, std::unique_ptr<PDBSymbol>> SymbolMap;
void SetUp() override {
InsertItemWithTag(PDB_SymType::None);
InsertItemWithTag(PDB_SymType::Exe);
InsertItemWithTag(PDB_SymType::Compiland);
InsertItemWithTag(PDB_SymType::CompilandDetails);
InsertItemWithTag(PDB_SymType::CompilandEnv);
InsertItemWithTag(PDB_SymType::Function);
InsertItemWithTag(PDB_SymType::Block);
InsertItemWithTag(PDB_SymType::Data);
InsertItemWithTag(PDB_SymType::Annotation);
InsertItemWithTag(PDB_SymType::Label);
InsertItemWithTag(PDB_SymType::PublicSymbol);
InsertItemWithTag(PDB_SymType::UDT);
InsertItemWithTag(PDB_SymType::Enum);
InsertItemWithTag(PDB_SymType::FunctionSig);
InsertItemWithTag(PDB_SymType::PointerType);
InsertItemWithTag(PDB_SymType::ArrayType);
InsertItemWithTag(PDB_SymType::BuiltinType);
InsertItemWithTag(PDB_SymType::Typedef);
InsertItemWithTag(PDB_SymType::BaseClass);
InsertItemWithTag(PDB_SymType::Friend);
InsertItemWithTag(PDB_SymType::FunctionArg);
InsertItemWithTag(PDB_SymType::FuncDebugStart);
InsertItemWithTag(PDB_SymType::FuncDebugEnd);
InsertItemWithTag(PDB_SymType::UsingNamespace);
InsertItemWithTag(PDB_SymType::VTableShape);
InsertItemWithTag(PDB_SymType::VTable);
InsertItemWithTag(PDB_SymType::Custom);
InsertItemWithTag(PDB_SymType::Thunk);
InsertItemWithTag(PDB_SymType::CustomType);
InsertItemWithTag(PDB_SymType::ManagedType);
InsertItemWithTag(PDB_SymType::Dimension);
InsertItemWithTag(PDB_SymType::Max);
}
private:
void InsertItemWithTag(PDB_SymType Tag) {
auto RawSymbol = std::unique_ptr<IPDBRawSymbol>(new MockRawSymbol(Tag));
auto Symbol = PDBSymbol::create(std::move(RawSymbol));
SymbolMap.insert(std::make_pair(Tag, std::move(Symbol)));
}
public:
template <class ExpectedType> void VerifyDyncast(PDB_SymType Tag) {
for (auto item = SymbolMap.begin(); item != SymbolMap.end(); ++item) {
EXPECT_EQ(item->first == Tag, llvm::isa<ExpectedType>(*item->second));
}
}
void VerifyUnknownDyncasts() {
for (auto item = SymbolMap.begin(); item != SymbolMap.end(); ++item) {
bool should_match = false;
if (item->first == PDB_SymType::None || item->first >= PDB_SymType::Max)
should_match = true;
EXPECT_EQ(should_match, llvm::isa<PDBSymbolUnknown>(*item->second));
}
}
};
TEST_F(PDBApiTest, Dyncast) {
// Most of the types have a one-to-one mapping between Tag and concrete type.
VerifyDyncast<PDBSymbolExe>(PDB_SymType::Exe);
VerifyDyncast<PDBSymbolCompiland>(PDB_SymType::Compiland);
VerifyDyncast<PDBSymbolCompilandDetails>(PDB_SymType::CompilandDetails);
VerifyDyncast<PDBSymbolCompilandEnv>(PDB_SymType::CompilandEnv);
VerifyDyncast<PDBSymbolFunc>(PDB_SymType::Function);
VerifyDyncast<PDBSymbolBlock>(PDB_SymType::Block);
VerifyDyncast<PDBSymbolData>(PDB_SymType::Data);
VerifyDyncast<PDBSymbolAnnotation>(PDB_SymType::Annotation);
VerifyDyncast<PDBSymbolLabel>(PDB_SymType::Label);
VerifyDyncast<PDBSymbolPublicSymbol>(PDB_SymType::PublicSymbol);
VerifyDyncast<PDBSymbolTypeUDT>(PDB_SymType::UDT);
VerifyDyncast<PDBSymbolTypeEnum>(PDB_SymType::Enum);
VerifyDyncast<PDBSymbolTypeFunctionSig>(PDB_SymType::FunctionSig);
VerifyDyncast<PDBSymbolTypePointer>(PDB_SymType::PointerType);
VerifyDyncast<PDBSymbolTypeArray>(PDB_SymType::ArrayType);
VerifyDyncast<PDBSymbolTypeBuiltin>(PDB_SymType::BuiltinType);
VerifyDyncast<PDBSymbolTypeTypedef>(PDB_SymType::Typedef);
VerifyDyncast<PDBSymbolTypeBaseClass>(PDB_SymType::BaseClass);
VerifyDyncast<PDBSymbolTypeFriend>(PDB_SymType::Friend);
VerifyDyncast<PDBSymbolTypeFunctionArg>(PDB_SymType::FunctionArg);
VerifyDyncast<PDBSymbolFuncDebugStart>(PDB_SymType::FuncDebugStart);
VerifyDyncast<PDBSymbolFuncDebugEnd>(PDB_SymType::FuncDebugEnd);
VerifyDyncast<PDBSymbolUsingNamespace>(PDB_SymType::UsingNamespace);
VerifyDyncast<PDBSymbolTypeVTableShape>(PDB_SymType::VTableShape);
VerifyDyncast<PDBSymbolTypeVTable>(PDB_SymType::VTable);
VerifyDyncast<PDBSymbolCustom>(PDB_SymType::Custom);
VerifyDyncast<PDBSymbolThunk>(PDB_SymType::Thunk);
VerifyDyncast<PDBSymbolTypeCustom>(PDB_SymType::CustomType);
VerifyDyncast<PDBSymbolTypeManaged>(PDB_SymType::ManagedType);
VerifyDyncast<PDBSymbolTypeDimension>(PDB_SymType::Dimension);
VerifyUnknownDyncasts();
}
} // end anonymous namespace