1
0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-25 12:12:47 +01:00
llvm-mirror/tools/llvm-readobj/CodeView.h
Reid Kleckner 7a79432e02 [codeview] Share more enums across the writer and the dumper
Moves some .def files into include/DebugInfo/CodeView.

Aslo remove a 'using namespace' directive from a header in readobj and
update the uses of the endian helper types to compensate.

llvm-svn: 257712
2016-01-13 23:44:57 +00:00

354 lines
9.9 KiB
C++

//===-- CodeView.h - On-disk record types for CodeView ----------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
///
/// \file
/// \brief This file provides data structures useful for consuming on-disk
/// CodeView. It is based on information published by Microsoft at
/// https://github.com/Microsoft/microsoft-pdb/.
///
//===----------------------------------------------------------------------===//
// FIXME: Find a home for this in include/llvm/DebugInfo/CodeView/.
#ifndef LLVM_READOBJ_CODEVIEW_H
#define LLVM_READOBJ_CODEVIEW_H
#include "llvm/DebugInfo/CodeView/CodeView.h"
#include "llvm/DebugInfo/CodeView/TypeIndex.h"
#include "llvm/Support/Endian.h"
namespace llvm {
namespace codeview {
using llvm::support::little32_t;
using llvm::support::ulittle16_t;
using llvm::support::ulittle32_t;
/// Data in the the SUBSEC_FRAMEDATA subection.
struct FrameData {
ulittle32_t RvaStart;
ulittle32_t CodeSize;
ulittle32_t LocalSize;
ulittle32_t ParamsSize;
ulittle32_t MaxStackSize;
ulittle32_t FrameFunc;
ulittle16_t PrologSize;
ulittle16_t SavedRegsSize;
ulittle32_t Flags;
enum : uint32_t {
HasSEH = 1 << 0,
HasEH = 1 << 1,
IsFunctionStart = 1 << 2,
};
};
//===----------------------------------------------------------------------===//
// On-disk representation of type information
// A CodeView type stream is a sequence of TypeRecords. Records larger than
// 65536 must chain on to a second record. Each TypeRecord is followed by one of
// the leaf types described below.
struct TypeRecordPrefix {
ulittle16_t Len; // Type record length, starting from &Leaf.
ulittle16_t Leaf; // Type record kind (TypeLeafKind)
};
// LF_TYPESERVER2
struct TypeServer2 {
char Signature[16]; // GUID
ulittle32_t Age;
// Name: Name of the PDB as a null-terminated string
};
// LF_STRING_ID
struct StringId {
TypeIndex id;
};
// LF_FUNC_ID
struct FuncId {
TypeIndex ParentScope;
TypeIndex FunctionType;
// Name: The null-terminated name follows.
};
// LF_CLASS, LF_STRUCT, LF_INTERFACE
struct ClassType {
ulittle16_t MemberCount; // Number of members in FieldList.
ulittle16_t Properties; // ClassOptions bitset
TypeIndex FieldList; // LF_FIELDLIST: List of all kinds of members
TypeIndex DerivedFrom; // LF_DERIVED: List of known derived classes
TypeIndex VShape; // LF_VTSHAPE: Shape of the vftable
// SizeOf: The 'sizeof' the UDT in bytes is encoded as an LF_NUMERIC integer.
// Name: The null-terminated name follows.
};
// LF_UNION
struct UnionType {
ulittle16_t MemberCount; // Number of members in FieldList.
ulittle16_t Properties; // ClassOptions bitset
TypeIndex FieldList; // LF_FIELDLIST: List of all kinds of members
// SizeOf: The 'sizeof' the UDT in bytes is encoded as an LF_NUMERIC integer.
// Name: The null-terminated name follows.
};
// LF_POINTER
struct PointerType {
TypeIndex PointeeType;
ulittle32_t Attrs; // pointer attributes
// if pointer to member:
// PointerToMemberTail
PointerKind getPtrKind() const { return PointerKind(Attrs & 0x1f); }
PointerMode getPtrMode() const { return PointerMode((Attrs >> 5) & 0x07); }
bool isFlat() const { return Attrs & (1 << 8); }
bool isVolatile() const { return Attrs & (1 << 9); }
bool isConst() const { return Attrs & (1 << 10); }
bool isUnaligned() const { return Attrs & (1 << 11); }
bool isPointerToDataMember() const {
return getPtrMode() == PointerMode::PointerToDataMember;
}
bool isPointerToMemberFunction() const {
return getPtrMode() == PointerMode::PointerToMemberFunction;
}
bool isPointerToMember() const {
return isPointerToMemberFunction() || isPointerToDataMember();
}
};
struct PointerToMemberTail {
TypeIndex ClassType;
ulittle16_t Representation; // PointerToMemberRepresentation
};
/// In Clang parlance, these are "qualifiers". LF_MODIFIER
struct TypeModifier {
TypeIndex ModifiedType;
ulittle16_t Modifiers; // ModifierOptions
};
// LF_VTSHAPE
struct VTableShape {
// Number of vftable entries. Each method may have more than one entry due to
// things like covariant return types.
ulittle16_t VFEntryCount;
// Descriptors[]: 4-bit virtual method descriptors of type CV_VTS_desc_e.
};
// LF_UDT_SRC_LINE
struct UDTSrcLine {
TypeIndex UDT; // The user-defined type
TypeIndex SourceFile; // StringID containing the source filename
ulittle32_t LineNumber;
};
// LF_ARGLIST, LF_SUBSTR_LIST
struct ArgList {
ulittle32_t NumArgs; // Number of arguments
// ArgTypes[]: Type indicies of arguments
};
// LF_BUILDINFO
struct BuildInfo {
ulittle16_t NumArgs; // Number of arguments
// ArgTypes[]: Type indicies of arguments
};
// LF_ENUM
struct EnumType {
ulittle16_t NumEnumerators; // Number of enumerators
ulittle16_t Properties;
TypeIndex UnderlyingType;
TypeIndex FieldListType;
// Name: The null-terminated name follows.
};
// LF_ARRAY
struct ArrayType {
TypeIndex ElementType;
TypeIndex IndexType;
// SizeOf: LF_NUMERIC encoded size in bytes. Not element count!
// Name: The null-terminated name follows.
};
// LF_VFTABLE
struct VFTableType {
TypeIndex CompleteClass; // Class that owns this vftable.
TypeIndex OverriddenVFTable; // VFTable that this overrides.
ulittle32_t VFPtrOffset; // VFPtr offset in CompleteClass
ulittle32_t NamesLen; // Length of subsequent names array in bytes.
// Names: A sequence of null-terminated strings. First string is vftable
// names.
};
// LF_MFUNC_ID
struct MemberFuncId {
TypeIndex ClassType;
TypeIndex FunctionType;
// Name: The null-terminated name follows.
};
// LF_PROCEDURE
struct ProcedureType {
TypeIndex ReturnType;
CallingConvention CallConv;
FunctionOptions Options;
ulittle16_t NumParameters;
TypeIndex ArgListType;
};
// LF_MFUNCTION
struct MemberFunctionType {
TypeIndex ReturnType;
TypeIndex ClassType;
TypeIndex ThisType;
CallingConvention CallConv;
FunctionOptions Options;
ulittle16_t NumParameters;
TypeIndex ArgListType;
little32_t ThisAdjustment;
};
//===----------------------------------------------------------------------===//
// Field list records, which do not include leafs or sizes
/// Equvalent to CV_fldattr_t in cvinfo.h.
struct MemberAttributes {
ulittle16_t Attrs;
/// Get the access specifier. Valid for any kind of member.
MemberAccess getAccess() const {
return MemberAccess(unsigned(Attrs) & unsigned(MethodOptions::AccessMask));
}
/// Indicates if a method is defined with friend, virtual, static, etc.
MethodKind getMethodKind() const {
return MethodKind(
(unsigned(Attrs) & unsigned(MethodOptions::MethodKindMask)) >> 2);
}
/// Get the flags that are not included in access control or method
/// properties.
MethodOptions getFlags() const {
return MethodOptions(
unsigned(Attrs) &
~unsigned(MethodOptions::AccessMask | MethodOptions::MethodKindMask));
}
/// Is this method virtual.
bool isVirtual() const {
auto MP = getMethodKind();
return MP != MethodKind::Vanilla && MP != MethodKind::Friend &&
MP != MethodKind::Static;
}
/// Does this member introduce a new virtual method.
bool isIntroducedVirtual() const {
auto MP = getMethodKind();
return MP == MethodKind::IntroducingVirtual ||
MP == MethodKind::PureIntroducingVirtual;
}
};
// LF_NESTTYPE
struct NestedType {
ulittle16_t Pad0; // Should be zero
TypeIndex Type; // Type index of nested type
// Name: Null-terminated string
};
// LF_ONEMETHOD
struct OneMethod {
MemberAttributes Attrs;
TypeIndex Type;
// If is introduced virtual method:
// VFTableOffset: int32_t offset in vftable
// Name: Null-terminated string
MethodKind getMethodKind() const {
return Attrs.getMethodKind();
}
bool isVirtual() const { return Attrs.isVirtual(); }
bool isIntroducedVirtual() const { return Attrs.isIntroducedVirtual(); }
};
struct MethodListEntry {
MemberAttributes Attrs;
ulittle16_t Padding;
TypeIndex Type;
// If is introduced virtual method:
// VFTableOffset: int32_t offset in vftable
MethodKind getMethodKind() const {
return Attrs.getMethodKind();
}
bool isVirtual() const { return Attrs.isVirtual(); }
bool isIntroducedVirtual() const { return Attrs.isIntroducedVirtual(); }
};
/// For method overload sets. LF_METHOD
struct OverloadedMethod {
ulittle16_t MethodCount; // Size of overload set
TypeIndex MethList; // Type index of methods in overload set
// Name: Null-terminated string
};
// LF_VFUNCTAB
struct VirtualFunctionPointer {
ulittle16_t Pad0;
TypeIndex Type; // Type of vfptr
};
// LF_MEMBER
struct DataMember {
MemberAttributes Attrs; // Access control attributes, etc
TypeIndex Type;
// FieldOffset: LF_NUMERIC encoded byte offset
// Name: Null-terminated string
};
// LF_STMEMBER
struct StaticDataMember {
MemberAttributes Attrs; // Access control attributes, etc
TypeIndex Type;
// Name: Null-terminated string
};
// LF_ENUMERATE
struct Enumerator {
MemberAttributes Attrs; // Access control attributes, etc
// EnumValue: LF_NUMERIC encoded enumerator value
// Name: Null-terminated string
};
// LF_BCLASS, LF_BINTERFACE
struct BaseClass {
MemberAttributes Attrs; // Access control attributes, etc
TypeIndex BaseType; // Base class type
// BaseOffset: LF_NUMERIC encoded byte offset of base from derived.
};
// LF_VBCLASS | LV_IVBCLASS
struct VirtualBaseClass {
MemberAttributes Attrs; // Access control attributes, etc.
TypeIndex BaseType; // Base class type
TypeIndex VBPtrType; // Virtual base pointer type
// VBPtrOffset: Offset of vbptr from vfptr encoded as LF_NUMERIC.
// VBTableIndex: Index of vbase within vbtable encoded as LF_NUMERIC.
};
} // namespace codeview
} // namespace llvm
#endif // LLVM_READOBJ_CODEVIEW_H