LCOV - code coverage report
Current view: top level - include/llvm/DebugInfo/CodeView - TypeIndex.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 20 21 95.2 %
Date: 2018-02-21 17:27:13 Functions: 0 0 -
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- TypeIndex.h ----------------------------------------------*- C++ -*-===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : 
      10             : #ifndef LLVM_DEBUGINFO_CODEVIEW_TYPEINDEX_H
      11             : #define LLVM_DEBUGINFO_CODEVIEW_TYPEINDEX_H
      12             : 
      13             : #include "llvm/ADT/DenseMapInfo.h"
      14             : #include "llvm/Support/Endian.h"
      15             : #include <cassert>
      16             : #include <cinttypes>
      17             : #include <functional>
      18             : 
      19             : namespace llvm {
      20             : 
      21             : class ScopedPrinter;
      22             : 
      23             : namespace codeview {
      24             : 
      25             : class TypeCollection;
      26             : 
      27             : enum class SimpleTypeKind : uint32_t {
      28             :   None = 0x0000,          // uncharacterized type (no type)
      29             :   Void = 0x0003,          // void
      30             :   NotTranslated = 0x0007, // type not translated by cvpack
      31             :   HResult = 0x0008,       // OLE/COM HRESULT
      32             : 
      33             :   SignedCharacter = 0x0010,   // 8 bit signed
      34             :   UnsignedCharacter = 0x0020, // 8 bit unsigned
      35             :   NarrowCharacter = 0x0070,   // really a char
      36             :   WideCharacter = 0x0071,     // wide char
      37             :   Character16 = 0x007a,       // char16_t
      38             :   Character32 = 0x007b,       // char32_t
      39             : 
      40             :   SByte = 0x0068,       // 8 bit signed int
      41             :   Byte = 0x0069,        // 8 bit unsigned int
      42             :   Int16Short = 0x0011,  // 16 bit signed
      43             :   UInt16Short = 0x0021, // 16 bit unsigned
      44             :   Int16 = 0x0072,       // 16 bit signed int
      45             :   UInt16 = 0x0073,      // 16 bit unsigned int
      46             :   Int32Long = 0x0012,   // 32 bit signed
      47             :   UInt32Long = 0x0022,  // 32 bit unsigned
      48             :   Int32 = 0x0074,       // 32 bit signed int
      49             :   UInt32 = 0x0075,      // 32 bit unsigned int
      50             :   Int64Quad = 0x0013,   // 64 bit signed
      51             :   UInt64Quad = 0x0023,  // 64 bit unsigned
      52             :   Int64 = 0x0076,       // 64 bit signed int
      53             :   UInt64 = 0x0077,      // 64 bit unsigned int
      54             :   Int128Oct = 0x0014,   // 128 bit signed int
      55             :   UInt128Oct = 0x0024,  // 128 bit unsigned int
      56             :   Int128 = 0x0078,      // 128 bit signed int
      57             :   UInt128 = 0x0079,     // 128 bit unsigned int
      58             : 
      59             :   Float16 = 0x0046,                 // 16 bit real
      60             :   Float32 = 0x0040,                 // 32 bit real
      61             :   Float32PartialPrecision = 0x0045, // 32 bit PP real
      62             :   Float48 = 0x0044,                 // 48 bit real
      63             :   Float64 = 0x0041,                 // 64 bit real
      64             :   Float80 = 0x0042,                 // 80 bit real
      65             :   Float128 = 0x0043,                // 128 bit real
      66             : 
      67             :   Complex16 = 0x0056,                 // 16 bit complex
      68             :   Complex32 = 0x0050,                 // 32 bit complex
      69             :   Complex32PartialPrecision = 0x0055, // 32 bit PP complex
      70             :   Complex48 = 0x0054,                 // 48 bit complex
      71             :   Complex64 = 0x0051,                 // 64 bit complex
      72             :   Complex80 = 0x0052,                 // 80 bit complex
      73             :   Complex128 = 0x0053,                // 128 bit complex
      74             : 
      75             :   Boolean8 = 0x0030,   // 8 bit boolean
      76             :   Boolean16 = 0x0031,  // 16 bit boolean
      77             :   Boolean32 = 0x0032,  // 32 bit boolean
      78             :   Boolean64 = 0x0033,  // 64 bit boolean
      79             :   Boolean128 = 0x0034, // 128 bit boolean
      80             : };
      81             : 
      82             : enum class SimpleTypeMode : uint32_t {
      83             :   Direct = 0x00000000,        // Not a pointer
      84             :   NearPointer = 0x00000100,   // Near pointer
      85             :   FarPointer = 0x00000200,    // Far pointer
      86             :   HugePointer = 0x00000300,   // Huge pointer
      87             :   NearPointer32 = 0x00000400, // 32 bit near pointer
      88             :   FarPointer32 = 0x00000500,  // 32 bit far pointer
      89             :   NearPointer64 = 0x00000600, // 64 bit near pointer
      90             :   NearPointer128 = 0x00000700 // 128 bit near pointer
      91             : };
      92             : 
      93             : /// A 32-bit type reference. Types are indexed by their order of appearance in
      94             : /// .debug$T plus 0x1000. Type indices less than 0x1000 are "simple" types,
      95             : /// composed of a SimpleTypeMode byte followed by a SimpleTypeKind byte.
      96             : class TypeIndex {
      97             : public:
      98             :   static const uint32_t FirstNonSimpleIndex = 0x1000;
      99             :   static const uint32_t SimpleKindMask = 0x000000ff;
     100             :   static const uint32_t SimpleModeMask = 0x00000700;
     101             :   static const uint32_t DecoratedItemIdMask = 0x80000000;
     102             : 
     103             : public:
     104             :   TypeIndex() : Index(static_cast<uint32_t>(SimpleTypeKind::None)) {}
     105             :   explicit TypeIndex(uint32_t Index) : Index(Index) {}
     106             :   explicit TypeIndex(SimpleTypeKind Kind)
     107             :       : Index(static_cast<uint32_t>(Kind)) {}
     108             :   TypeIndex(SimpleTypeKind Kind, SimpleTypeMode Mode)
     109          10 :       : Index(static_cast<uint32_t>(Kind) | static_cast<uint32_t>(Mode)) {}
     110             : 
     111             :   uint32_t getIndex() const { return Index; }
     112             :   void setIndex(uint32_t I) { Index = I; }
     113             :   bool isSimple() const { return Index < FirstNonSimpleIndex; }
     114          57 :   bool isDecoratedItemId() const { return !!(Index & DecoratedItemIdMask); }
     115             : 
     116       50498 :   bool isNoneType() const { return *this == None(); }
     117             : 
     118             :   uint32_t toArrayIndex() const {
     119             :     assert(!isSimple());
     120       29822 :     return getIndex() - FirstNonSimpleIndex;
     121             :   }
     122             : 
     123             :   static TypeIndex fromArrayIndex(uint32_t Index) {
     124       11609 :     return TypeIndex(Index + FirstNonSimpleIndex);
     125             :   }
     126             : 
     127             :   SimpleTypeKind getSimpleKind() const {
     128             :     assert(isSimple());
     129       19067 :     return static_cast<SimpleTypeKind>(Index & SimpleKindMask);
     130             :   }
     131             : 
     132             :   SimpleTypeMode getSimpleMode() const {
     133             :     assert(isSimple());
     134        1603 :     return static_cast<SimpleTypeMode>(Index & SimpleModeMask);
     135             :   }
     136             : 
     137       27796 :   static TypeIndex None() { return TypeIndex(SimpleTypeKind::None); }
     138         466 :   static TypeIndex Void() { return TypeIndex(SimpleTypeKind::Void); }
     139             :   static TypeIndex VoidPointer32() {
     140             :     return TypeIndex(SimpleTypeKind::Void, SimpleTypeMode::NearPointer32);
     141             :   }
     142             :   static TypeIndex VoidPointer64() {
     143             :     return TypeIndex(SimpleTypeKind::Void, SimpleTypeMode::NearPointer64);
     144             :   }
     145             : 
     146             :   static TypeIndex SignedCharacter() {
     147             :     return TypeIndex(SimpleTypeKind::SignedCharacter);
     148             :   }
     149             :   static TypeIndex UnsignedCharacter() {
     150             :     return TypeIndex(SimpleTypeKind::UnsignedCharacter);
     151             :   }
     152             :   static TypeIndex NarrowCharacter() {
     153             :     return TypeIndex(SimpleTypeKind::NarrowCharacter);
     154             :   }
     155             :   static TypeIndex WideCharacter() {
     156             :     return TypeIndex(SimpleTypeKind::WideCharacter);
     157             :   }
     158             :   static TypeIndex Int16Short() {
     159             :     return TypeIndex(SimpleTypeKind::Int16Short);
     160             :   }
     161             :   static TypeIndex UInt16Short() {
     162             :     return TypeIndex(SimpleTypeKind::UInt16Short);
     163             :   }
     164          69 :   static TypeIndex Int32() { return TypeIndex(SimpleTypeKind::Int32); }
     165          67 :   static TypeIndex UInt32() { return TypeIndex(SimpleTypeKind::UInt32); }
     166             :   static TypeIndex Int32Long() { return TypeIndex(SimpleTypeKind::Int32Long); }
     167             :   static TypeIndex UInt32Long() {
     168             :     return TypeIndex(SimpleTypeKind::UInt32Long);
     169             :   }
     170             :   static TypeIndex Int64() { return TypeIndex(SimpleTypeKind::Int64); }
     171             :   static TypeIndex UInt64() { return TypeIndex(SimpleTypeKind::UInt64); }
     172             :   static TypeIndex Int64Quad() { return TypeIndex(SimpleTypeKind::Int64Quad); }
     173             :   static TypeIndex UInt64Quad() {
     174             :     return TypeIndex(SimpleTypeKind::UInt64Quad);
     175             :   }
     176             : 
     177           2 :   static TypeIndex Float32() { return TypeIndex(SimpleTypeKind::Float32); }
     178           1 :   static TypeIndex Float64() { return TypeIndex(SimpleTypeKind::Float64); }
     179             : 
     180             :   TypeIndex &operator+=(unsigned N) {
     181             :     Index += N;
     182             :     return *this;
     183             :   }
     184             : 
     185             :   TypeIndex &operator++() {
     186             :     Index += 1;
     187             :     return *this;
     188             :   }
     189             : 
     190             :   TypeIndex operator++(int) {
     191         213 :     TypeIndex Copy = *this;
     192             :     operator++();
     193         213 :     return Copy;
     194             :   }
     195             : 
     196             :   TypeIndex &operator-=(unsigned N) {
     197             :     assert(Index >= N);
     198             :     Index -= N;
     199             :     return *this;
     200             :   }
     201             : 
     202             :   TypeIndex &operator--() {
     203             :     Index -= 1;
     204             :     return *this;
     205             :   }
     206             : 
     207             :   TypeIndex operator--(int) {
     208             :     TypeIndex Copy = *this;
     209             :     operator--();
     210             :     return Copy;
     211             :   }
     212             : 
     213             :   friend inline bool operator==(const TypeIndex &A, const TypeIndex &B) {
     214        2208 :     return A.getIndex() == B.getIndex();
     215             :   }
     216             : 
     217             :   friend inline bool operator!=(const TypeIndex &A, const TypeIndex &B) {
     218             :     return A.getIndex() != B.getIndex();
     219             :   }
     220             : 
     221             :   friend inline bool operator<(const TypeIndex &A, const TypeIndex &B) {
     222           0 :     return A.getIndex() < B.getIndex();
     223             :   }
     224             : 
     225             :   friend inline bool operator<=(const TypeIndex &A, const TypeIndex &B) {
     226             :     return A.getIndex() <= B.getIndex();
     227             :   }
     228             : 
     229             :   friend inline bool operator>(const TypeIndex &A, const TypeIndex &B) {
     230             :     return A.getIndex() > B.getIndex();
     231             :   }
     232             : 
     233             :   friend inline bool operator>=(const TypeIndex &A, const TypeIndex &B) {
     234             :     return A.getIndex() >= B.getIndex();
     235             :   }
     236             : 
     237             :   friend inline TypeIndex operator+(const TypeIndex &A, uint32_t N) {
     238        4431 :     TypeIndex Result(A);
     239             :     Result += N;
     240        4431 :     return Result;
     241             :   }
     242             : 
     243             :   friend inline TypeIndex operator-(const TypeIndex &A, uint32_t N) {
     244             :     assert(A.getIndex() >= N);
     245             :     TypeIndex Result(A);
     246             :     Result -= N;
     247             :     return Result;
     248             :   }
     249             : 
     250             :   friend inline uint32_t operator-(const TypeIndex &A, const TypeIndex &B) {
     251             :     assert(A >= B);
     252             :     return A.toArrayIndex() - B.toArrayIndex();
     253             :   }
     254             : 
     255             :   static StringRef simpleTypeName(TypeIndex TI);
     256             : 
     257             : private:
     258             :   support::ulittle32_t Index;
     259             : };
     260             : 
     261             : // Used for pseudo-indexing an array of type records.  An array of such records
     262             : // sorted by TypeIndex can allow log(N) lookups even though such a type record
     263             : // stream does not provide random access.
     264             : struct TypeIndexOffset {
     265             :   TypeIndex Type;
     266             :   support::ulittle32_t Offset;
     267             : };
     268             : 
     269             : void printTypeIndex(ScopedPrinter &Printer, StringRef FieldName, TypeIndex TI,
     270             :                     TypeCollection &Types);
     271             : }
     272             : 
     273             : template <> struct DenseMapInfo<codeview::TypeIndex> {
     274             :   static inline codeview::TypeIndex getEmptyKey() {
     275          47 :     return codeview::TypeIndex{DenseMapInfo<uint32_t>::getEmptyKey()};
     276             :   }
     277             :   static inline codeview::TypeIndex getTombstoneKey() {
     278          36 :     return codeview::TypeIndex{DenseMapInfo<uint32_t>::getTombstoneKey()};
     279             :   }
     280             :   static unsigned getHashValue(const codeview::TypeIndex &TI) {
     281             :     return DenseMapInfo<uint32_t>::getHashValue(TI.getIndex());
     282             :   }
     283             :   static bool isEqual(const codeview::TypeIndex &LHS,
     284             :                       const codeview::TypeIndex &RHS) {
     285             :     return LHS == RHS;
     286             :   }
     287             : };
     288             : 
     289             : } // namespace llvm
     290             : 
     291             : #endif

Generated by: LCOV version 1.13