LCOV - code coverage report
Current view: top level - lib/DebugInfo/PDB/Native - NativeTypeUDT.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 119 124 96.0 %
Date: 2018-10-20 13:21:21 Functions: 26 27 96.3 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- NativeTypeUDT.cpp - info about class/struct type ---------*- 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             : #include "llvm/DebugInfo/PDB/Native/NativeTypeUDT.h"
      11             : 
      12             : #include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
      13             : 
      14             : #include <cassert>
      15             : 
      16             : using namespace llvm;
      17             : using namespace llvm::codeview;
      18             : using namespace llvm::pdb;
      19             : 
      20          74 : NativeTypeUDT::NativeTypeUDT(NativeSession &Session, SymIndexId Id,
      21          74 :                              codeview::TypeIndex TI, codeview::ClassRecord CR)
      22             :     : NativeRawSymbol(Session, PDB_SymType::UDT, Id), Index(TI),
      23          74 :       Class(std::move(CR)), Tag(Class.getPointer()) {}
      24             : 
      25           2 : NativeTypeUDT::NativeTypeUDT(NativeSession &Session, SymIndexId Id,
      26           2 :                              codeview::TypeIndex TI, codeview::UnionRecord UR)
      27             :     : NativeRawSymbol(Session, PDB_SymType::UDT, Id), Index(TI),
      28           2 :       Union(std::move(UR)), Tag(Union.getPointer()) {}
      29             : 
      30          20 : NativeTypeUDT::NativeTypeUDT(NativeSession &Session, SymIndexId Id,
      31             :                              NativeTypeUDT &UnmodifiedType,
      32          20 :                              codeview::ModifierRecord Modifier)
      33             :     : NativeRawSymbol(Session, PDB_SymType::UDT, Id),
      34          20 :       UnmodifiedType(&UnmodifiedType), Modifiers(std::move(Modifier)) {}
      35             : 
      36         192 : NativeTypeUDT::~NativeTypeUDT() {}
      37             : 
      38          22 : void NativeTypeUDT::dump(raw_ostream &OS, int Indent,
      39             :                          PdbSymbolIdField ShowIdFields,
      40             :                          PdbSymbolIdField RecurseIdFields) const {
      41             : 
      42          22 :   NativeRawSymbol::dump(OS, Indent, ShowIdFields, RecurseIdFields);
      43             : 
      44          22 :   dumpSymbolField(OS, "name", getName(), Indent);
      45          44 :   dumpSymbolIdField(OS, "lexicalParentId", 0, Indent, Session,
      46             :                     PdbSymbolIdField::LexicalParent, ShowIdFields,
      47             :                     RecurseIdFields);
      48          22 :   if (Modifiers.hasValue())
      49           4 :     dumpSymbolIdField(OS, "unmodifiedTypeId", getUnmodifiedTypeId(), Indent,
      50           4 :                       Session, PdbSymbolIdField::UnmodifiedType, ShowIdFields,
      51             :                       RecurseIdFields);
      52          22 :   if (getUdtKind() != PDB_UdtType::Union)
      53          21 :     dumpSymbolField(OS, "virtualTableShapeId", getVirtualTableShapeId(),
      54             :                     Indent);
      55          22 :   dumpSymbolField(OS, "length", getLength(), Indent);
      56          22 :   dumpSymbolField(OS, "udtKind", getUdtKind(), Indent);
      57          22 :   dumpSymbolField(OS, "constructor", hasConstructor(), Indent);
      58          22 :   dumpSymbolField(OS, "constType", isConstType(), Indent);
      59          22 :   dumpSymbolField(OS, "hasAssignmentOperator", hasAssignmentOperator(), Indent);
      60          22 :   dumpSymbolField(OS, "hasCastOperator", hasCastOperator(), Indent);
      61          22 :   dumpSymbolField(OS, "hasNestedTypes", hasNestedTypes(), Indent);
      62          22 :   dumpSymbolField(OS, "overloadedOperator", hasOverloadedOperator(), Indent);
      63          22 :   dumpSymbolField(OS, "isInterfaceUdt", isInterfaceUdt(), Indent);
      64          22 :   dumpSymbolField(OS, "intrinsic", isIntrinsic(), Indent);
      65          22 :   dumpSymbolField(OS, "nested", isNested(), Indent);
      66          22 :   dumpSymbolField(OS, "packed", isPacked(), Indent);
      67          22 :   dumpSymbolField(OS, "isRefUdt", isRefUdt(), Indent);
      68          22 :   dumpSymbolField(OS, "scoped", isScoped(), Indent);
      69          22 :   dumpSymbolField(OS, "unalignedType", isUnalignedType(), Indent);
      70          22 :   dumpSymbolField(OS, "isValueUdt", isValueUdt(), Indent);
      71          22 :   dumpSymbolField(OS, "volatileType", isVolatileType(), Indent);
      72          22 : }
      73             : 
      74         189 : std::string NativeTypeUDT::getName() const {
      75         189 :   if (UnmodifiedType)
      76          24 :     return UnmodifiedType->getName();
      77             : 
      78         165 :   return Tag->getName();
      79             : }
      80             : 
      81           0 : SymIndexId NativeTypeUDT::getLexicalParentId() const { return 0; }
      82             : 
      83          46 : SymIndexId NativeTypeUDT::getUnmodifiedTypeId() const {
      84          46 :   if (UnmodifiedType)
      85          16 :     return UnmodifiedType->getSymIndexId();
      86             : 
      87             :   return 0;
      88             : }
      89             : 
      90          25 : SymIndexId NativeTypeUDT::getVirtualTableShapeId() const {
      91          25 :   if (UnmodifiedType)
      92           4 :     return UnmodifiedType->getVirtualTableShapeId();
      93             : 
      94          21 :   if (Class)
      95          42 :     return Session.getSymbolCache().findSymbolByTypeIndex(Class->VTableShape);
      96             : 
      97             :   return 0;
      98             : }
      99             : 
     100          70 : uint64_t NativeTypeUDT::getLength() const {
     101          70 :   if (UnmodifiedType)
     102           8 :     return UnmodifiedType->getLength();
     103             : 
     104          62 :   if (Class)
     105          59 :     return Class->getSize();
     106             : 
     107           3 :   return Union->getSize();
     108             : }
     109             : 
     110          98 : PDB_UdtType NativeTypeUDT::getUdtKind() const {
     111          98 :   if (UnmodifiedType)
     112          16 :     return UnmodifiedType->getUdtKind();
     113             : 
     114          82 :   switch (Tag->Kind) {
     115             :   case TypeRecordKind::Class:
     116             :     return PDB_UdtType::Class;
     117           3 :   case TypeRecordKind::Union:
     118           3 :     return PDB_UdtType::Union;
     119          76 :   case TypeRecordKind::Struct:
     120          76 :     return PDB_UdtType::Struct;
     121           0 :   case TypeRecordKind::Interface:
     122           0 :     return PDB_UdtType::Interface;
     123           0 :   default:
     124           0 :     llvm_unreachable("Unexected udt kind");
     125             :   }
     126             : }
     127             : 
     128          26 : bool NativeTypeUDT::hasConstructor() const {
     129          26 :   if (UnmodifiedType)
     130           4 :     return UnmodifiedType->hasConstructor();
     131             : 
     132          22 :   return (Tag->Options & ClassOptions::HasConstructorOrDestructor) !=
     133          22 :          ClassOptions::None;
     134             : }
     135             : 
     136          48 : bool NativeTypeUDT::isConstType() const {
     137          48 :   if (!Modifiers)
     138             :     return false;
     139          12 :   return (Modifiers->Modifiers & ModifierOptions::Const) !=
     140          12 :          ModifierOptions::None;
     141             : }
     142             : 
     143          26 : bool NativeTypeUDT::hasAssignmentOperator() const {
     144          26 :   if (UnmodifiedType)
     145           4 :     return UnmodifiedType->hasAssignmentOperator();
     146             : 
     147          22 :   return (Tag->Options & ClassOptions::HasOverloadedAssignmentOperator) !=
     148          22 :          ClassOptions::None;
     149             : }
     150             : 
     151          26 : bool NativeTypeUDT::hasCastOperator() const {
     152          26 :   if (UnmodifiedType)
     153           4 :     return UnmodifiedType->hasCastOperator();
     154             : 
     155          22 :   return (Tag->Options & ClassOptions::HasConversionOperator) !=
     156          22 :          ClassOptions::None;
     157             : }
     158             : 
     159          26 : bool NativeTypeUDT::hasNestedTypes() const {
     160          26 :   if (UnmodifiedType)
     161           4 :     return UnmodifiedType->hasNestedTypes();
     162             : 
     163          22 :   return (Tag->Options & ClassOptions::ContainsNestedClass) !=
     164          22 :          ClassOptions::None;
     165             : }
     166             : 
     167          26 : bool NativeTypeUDT::hasOverloadedOperator() const {
     168          26 :   if (UnmodifiedType)
     169           4 :     return UnmodifiedType->hasOverloadedOperator();
     170             : 
     171          22 :   return (Tag->Options & ClassOptions::HasOverloadedOperator) !=
     172          22 :          ClassOptions::None;
     173             : }
     174             : 
     175          22 : bool NativeTypeUDT::isInterfaceUdt() const { return false; }
     176             : 
     177          26 : bool NativeTypeUDT::isIntrinsic() const {
     178          26 :   if (UnmodifiedType)
     179           4 :     return UnmodifiedType->isIntrinsic();
     180             : 
     181          44 :   return (Tag->Options & ClassOptions::Intrinsic) != ClassOptions::None;
     182             : }
     183             : 
     184          26 : bool NativeTypeUDT::isNested() const {
     185          26 :   if (UnmodifiedType)
     186           4 :     return UnmodifiedType->isNested();
     187             : 
     188          44 :   return (Tag->Options & ClassOptions::Nested) != ClassOptions::None;
     189             : }
     190             : 
     191          26 : bool NativeTypeUDT::isPacked() const {
     192          26 :   if (UnmodifiedType)
     193           4 :     return UnmodifiedType->isPacked();
     194             : 
     195          44 :   return (Tag->Options & ClassOptions::Packed) != ClassOptions::None;
     196             : }
     197             : 
     198          22 : bool NativeTypeUDT::isRefUdt() const { return false; }
     199             : 
     200          26 : bool NativeTypeUDT::isScoped() const {
     201          26 :   if (UnmodifiedType)
     202           4 :     return UnmodifiedType->isScoped();
     203             : 
     204          44 :   return (Tag->Options & ClassOptions::Scoped) != ClassOptions::None;
     205             : }
     206             : 
     207          22 : bool NativeTypeUDT::isValueUdt() const { return false; }
     208             : 
     209          48 : bool NativeTypeUDT::isUnalignedType() const {
     210          48 :   if (!Modifiers)
     211             :     return false;
     212          12 :   return (Modifiers->Modifiers & ModifierOptions::Unaligned) !=
     213          12 :          ModifierOptions::None;
     214             : }
     215             : 
     216          48 : bool NativeTypeUDT::isVolatileType() const {
     217          48 :   if (!Modifiers)
     218             :     return false;
     219          12 :   return (Modifiers->Modifiers & ModifierOptions::Volatile) !=
     220          12 :          ModifierOptions::None;
     221             : }

Generated by: LCOV version 1.13