LCOV - code coverage report
Current view: top level - lib/DebugInfo/PDB - UDTLayout.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 0 154 0.0 %
Date: 2017-09-14 15:23:50 Functions: 0 19 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- UDTLayout.cpp ------------------------------------------------------===//
       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/UDTLayout.h"
      11             : #include "llvm/ADT/ArrayRef.h"
      12             : #include "llvm/ADT/BitVector.h"
      13             : #include "llvm/ADT/STLExtras.h"
      14             : #include "llvm/DebugInfo/PDB/IPDBRawSymbol.h"
      15             : #include "llvm/DebugInfo/PDB/IPDBSession.h"
      16             : #include "llvm/DebugInfo/PDB/PDBSymbol.h"
      17             : #include "llvm/DebugInfo/PDB/PDBSymbolData.h"
      18             : #include "llvm/DebugInfo/PDB/PDBSymbolFunc.h"
      19             : #include "llvm/DebugInfo/PDB/PDBSymbolTypeBaseClass.h"
      20             : #include "llvm/DebugInfo/PDB/PDBSymbolTypeBuiltin.h"
      21             : #include "llvm/DebugInfo/PDB/PDBSymbolTypePointer.h"
      22             : #include "llvm/DebugInfo/PDB/PDBSymbolTypeUDT.h"
      23             : #include "llvm/DebugInfo/PDB/PDBSymbolTypeVTable.h"
      24             : #include "llvm/DebugInfo/PDB/PDBTypes.h"
      25             : #include "llvm/Support/Casting.h"
      26             : #include <algorithm>
      27             : #include <cassert>
      28             : #include <cstdint>
      29             : #include <memory>
      30             : 
      31             : using namespace llvm;
      32             : using namespace llvm::pdb;
      33             : 
      34             : static std::unique_ptr<PDBSymbol> getSymbolType(const PDBSymbol &Symbol) {
      35           0 :   const IPDBSession &Session = Symbol.getSession();
      36           0 :   const IPDBRawSymbol &RawSymbol = Symbol.getRawSymbol();
      37           0 :   uint32_t TypeId = RawSymbol.getTypeId();
      38           0 :   return Session.getSymbolById(TypeId);
      39             : }
      40             : 
      41           0 : static uint32_t getTypeLength(const PDBSymbol &Symbol) {
      42           0 :   auto SymbolType = getSymbolType(Symbol);
      43           0 :   const IPDBRawSymbol &RawType = SymbolType->getRawSymbol();
      44             : 
      45           0 :   return RawType.getLength();
      46             : }
      47             : 
      48           0 : LayoutItemBase::LayoutItemBase(const UDTLayoutBase *Parent,
      49             :                                const PDBSymbol *Symbol, const std::string &Name,
      50             :                                uint32_t OffsetInParent, uint32_t Size,
      51           0 :                                bool IsElided)
      52             :     : Symbol(Symbol), Parent(Parent), Name(Name),
      53             :       OffsetInParent(OffsetInParent), SizeOf(Size), LayoutSize(Size),
      54           0 :       IsElided(IsElided) {
      55           0 :   UsedBytes.resize(SizeOf, true);
      56           0 : }
      57             : 
      58           0 : uint32_t LayoutItemBase::deepPaddingSize() const {
      59           0 :   return UsedBytes.size() - UsedBytes.count();
      60             : }
      61             : 
      62           0 : uint32_t LayoutItemBase::tailPadding() const {
      63           0 :   int Last = UsedBytes.find_last();
      64             : 
      65           0 :   return UsedBytes.size() - (Last + 1);
      66             : }
      67             : 
      68           0 : DataMemberLayoutItem::DataMemberLayoutItem(
      69           0 :     const UDTLayoutBase &Parent, std::unique_ptr<PDBSymbolData> Member)
      70           0 :     : LayoutItemBase(&Parent, Member.get(), Member->getName(),
      71           0 :                      Member->getOffset(), getTypeLength(*Member), false),
      72           0 :       DataMember(std::move(Member)) {
      73           0 :   auto Type = DataMember->getType();
      74           0 :   if (auto UDT = unique_dyn_cast<PDBSymbolTypeUDT>(Type)) {
      75           0 :     UdtLayout = llvm::make_unique<ClassLayout>(std::move(UDT));
      76           0 :     UsedBytes = UdtLayout->usedBytes();
      77             :   }
      78           0 : }
      79             : 
      80           0 : VBPtrLayoutItem::VBPtrLayoutItem(const UDTLayoutBase &Parent,
      81             :                                  std::unique_ptr<PDBSymbolTypeBuiltin> Sym,
      82           0 :                                  uint32_t Offset, uint32_t Size)
      83           0 :     : LayoutItemBase(&Parent, Sym.get(), "<vbptr>", Offset, Size, false),
      84           0 :       Type(std::move(Sym)) {
      85           0 : }
      86             : 
      87           0 : const PDBSymbolData &DataMemberLayoutItem::getDataMember() {
      88           0 :   return *dyn_cast<PDBSymbolData>(Symbol);
      89             : }
      90             : 
      91           0 : bool DataMemberLayoutItem::hasUDTLayout() const { return UdtLayout != nullptr; }
      92             : 
      93           0 : const ClassLayout &DataMemberLayoutItem::getUDTLayout() const {
      94           0 :   return *UdtLayout;
      95             : }
      96             : 
      97           0 : VTableLayoutItem::VTableLayoutItem(const UDTLayoutBase &Parent,
      98           0 :                                    std::unique_ptr<PDBSymbolTypeVTable> VT)
      99           0 :     : LayoutItemBase(&Parent, VT.get(), "<vtbl>", 0, getTypeLength(*VT), false),
     100           0 :       VTable(std::move(VT)) {
     101           0 :   auto VTableType = cast<PDBSymbolTypePointer>(VTable->getType());
     102           0 :   ElementSize = VTableType->getLength();
     103           0 : }
     104             : 
     105           0 : UDTLayoutBase::UDTLayoutBase(const UDTLayoutBase *Parent, const PDBSymbol &Sym,
     106             :                              const std::string &Name, uint32_t OffsetInParent,
     107           0 :                              uint32_t Size, bool IsElided)
     108           0 :     : LayoutItemBase(Parent, &Sym, Name, OffsetInParent, Size, IsElided) {
     109             :   // UDT storage comes from a union of all the children's storage, so start out
     110             :   // uninitialized.
     111           0 :   UsedBytes.reset(0, Size);
     112             : 
     113           0 :   initializeChildren(Sym);
     114           0 :   if (LayoutSize < Size)
     115           0 :     UsedBytes.resize(LayoutSize);
     116           0 : }
     117             : 
     118           0 : uint32_t UDTLayoutBase::tailPadding() const {
     119           0 :   uint32_t Abs = LayoutItemBase::tailPadding();
     120           0 :   if (!LayoutItems.empty()) {
     121           0 :     const LayoutItemBase *Back = LayoutItems.back();
     122           0 :     uint32_t ChildPadding = Back->LayoutItemBase::tailPadding();
     123           0 :     if (Abs < ChildPadding)
     124             :       Abs = 0;
     125             :     else
     126           0 :       Abs -= ChildPadding;
     127             :   }
     128           0 :   return Abs;
     129             : }
     130             : 
     131           0 : ClassLayout::ClassLayout(const PDBSymbolTypeUDT &UDT)
     132           0 :     : UDTLayoutBase(nullptr, UDT, UDT.getName(), 0, UDT.getLength(), false),
     133           0 :       UDT(UDT) {
     134           0 :   ImmediateUsedBytes.resize(SizeOf, false);
     135           0 :   for (auto &LI : LayoutItems) {
     136           0 :     uint32_t Begin = LI->getOffsetInParent();
     137           0 :     uint32_t End = Begin + LI->getLayoutSize();
     138           0 :     End = std::min(SizeOf, End);
     139           0 :     ImmediateUsedBytes.set(Begin, End);
     140             :   }
     141           0 : }
     142             : 
     143           0 : ClassLayout::ClassLayout(std::unique_ptr<PDBSymbolTypeUDT> UDT)
     144           0 :     : ClassLayout(*UDT) {
     145           0 :   OwnedStorage = std::move(UDT);
     146           0 : }
     147             : 
     148           0 : uint32_t ClassLayout::immediatePadding() const {
     149           0 :   return SizeOf - ImmediateUsedBytes.count();
     150             : }
     151             : 
     152           0 : BaseClassLayout::BaseClassLayout(const UDTLayoutBase &Parent,
     153             :                                  uint32_t OffsetInParent, bool Elide,
     154           0 :                                  std::unique_ptr<PDBSymbolTypeBaseClass> B)
     155           0 :     : UDTLayoutBase(&Parent, *B, B->getName(), OffsetInParent, B->getLength(),
     156             :                     Elide),
     157           0 :       Base(std::move(B)) {
     158           0 :   if (isEmptyBase()) {
     159             :     // Special case an empty base so that it doesn't get treated as padding.
     160           0 :     UsedBytes.resize(1);
     161           0 :     UsedBytes.set(0);
     162             :   }
     163           0 :   IsVirtualBase = Base->isVirtualBaseClass();
     164           0 : }
     165             : 
     166           0 : void UDTLayoutBase::initializeChildren(const PDBSymbol &Sym) {
     167             :   // Handled bases first, followed by VTables, followed by data members,
     168             :   // followed by functions, followed by other.  This ordering is necessary
     169             :   // so that bases and vtables get initialized before any functions which
     170             :   // may override them.
     171           0 :   UniquePtrVector<PDBSymbolTypeBaseClass> Bases;
     172           0 :   UniquePtrVector<PDBSymbolTypeVTable> VTables;
     173           0 :   UniquePtrVector<PDBSymbolData> Members;
     174           0 :   UniquePtrVector<PDBSymbolTypeBaseClass> VirtualBaseSyms;
     175             : 
     176           0 :   auto Children = Sym.findAllChildren();
     177           0 :   while (auto Child = Children->getNext()) {
     178           0 :     if (auto Base = unique_dyn_cast<PDBSymbolTypeBaseClass>(Child)) {
     179           0 :       if (Base->isVirtualBaseClass())
     180           0 :         VirtualBaseSyms.push_back(std::move(Base));
     181             :       else
     182           0 :         Bases.push_back(std::move(Base));
     183             :     }
     184           0 :     else if (auto Data = unique_dyn_cast<PDBSymbolData>(Child)) {
     185           0 :       if (Data->getDataKind() == PDB_DataKind::Member)
     186           0 :         Members.push_back(std::move(Data));
     187             :       else
     188           0 :         Other.push_back(std::move(Data));
     189           0 :     } else if (auto VT = unique_dyn_cast<PDBSymbolTypeVTable>(Child))
     190           0 :       VTables.push_back(std::move(VT));
     191           0 :     else if (auto Func = unique_dyn_cast<PDBSymbolFunc>(Child))
     192           0 :       Funcs.push_back(std::move(Func));
     193             :     else {
     194           0 :       Other.push_back(std::move(Child));
     195             :     }
     196             :   }
     197             : 
     198             :   // We don't want to have any re-allocations in the list of bases, so make
     199             :   // sure to reserve enough space so that our ArrayRefs don't get invalidated.
     200           0 :   AllBases.reserve(Bases.size() + VirtualBaseSyms.size());
     201             : 
     202             :   // Only add non-virtual bases to the class first.  Only at the end of the
     203             :   // class, after all non-virtual bases and data members have been added do we
     204             :   // add virtual bases.  This way the offsets are correctly aligned when we go
     205             :   // to lay out virtual bases.
     206           0 :   for (auto &Base : Bases) {
     207           0 :     uint32_t Offset = Base->getOffset();
     208             :     // Non-virtual bases never get elided.
     209             :     auto BL = llvm::make_unique<BaseClassLayout>(*this, Offset, false,
     210           0 :                                                  std::move(Base));
     211             : 
     212           0 :     AllBases.push_back(BL.get());
     213           0 :     addChildToLayout(std::move(BL));
     214             :   }
     215           0 :   NonVirtualBases = AllBases;
     216             : 
     217             :   assert(VTables.size() <= 1);
     218           0 :   if (!VTables.empty()) {
     219             :     auto VTLayout =
     220           0 :         llvm::make_unique<VTableLayoutItem>(*this, std::move(VTables[0]));
     221             : 
     222           0 :     VTable = VTLayout.get();
     223             : 
     224           0 :     addChildToLayout(std::move(VTLayout));
     225             :   }
     226             : 
     227           0 :   for (auto &Data : Members) {
     228           0 :     auto DM = llvm::make_unique<DataMemberLayoutItem>(*this, std::move(Data));
     229             : 
     230           0 :     addChildToLayout(std::move(DM));
     231             :   }
     232             : 
     233             :   // Make sure add virtual bases before adding functions, since functions may be
     234             :   // overrides of virtual functions declared in a virtual base, so the VTables
     235             :   // and virtual intros need to be correctly initialized.
     236           0 :   for (auto &VB : VirtualBaseSyms) {
     237           0 :     int VBPO = VB->getVirtualBasePointerOffset();
     238           0 :     if (!hasVBPtrAtOffset(VBPO)) {
     239           0 :       if (auto VBP = VB->getRawSymbol().getVirtualBaseTableType()) {
     240           0 :         auto VBPL = llvm::make_unique<VBPtrLayoutItem>(*this, std::move(VBP),
     241           0 :                                                        VBPO, VBP->getLength());
     242           0 :         VBPtr = VBPL.get();
     243           0 :         addChildToLayout(std::move(VBPL));
     244             :       }
     245             :     }
     246             : 
     247             :     // Virtual bases always go at the end.  So just look for the last place we
     248             :     // ended when writing something, and put our virtual base there.
     249             :     // Note that virtual bases get elided unless this is a top-most derived
     250             :     // class.
     251           0 :     uint32_t Offset = UsedBytes.find_last() + 1;
     252           0 :     bool Elide = (Parent != nullptr);
     253             :     auto BL =
     254           0 :         llvm::make_unique<BaseClassLayout>(*this, Offset, Elide, std::move(VB));
     255           0 :     AllBases.push_back(BL.get());
     256             : 
     257             :     // Only lay this virtual base out directly inside of *this* class if this
     258             :     // is a top-most derived class.  Keep track of it regardless, but only
     259             :     // physically lay it out if it's a topmost derived class.
     260           0 :     addChildToLayout(std::move(BL));
     261             :   }
     262           0 :   VirtualBases = makeArrayRef(AllBases).drop_front(NonVirtualBases.size());
     263             : 
     264           0 :   if (Parent != nullptr)
     265           0 :     LayoutSize = UsedBytes.find_last() + 1;
     266           0 : }
     267             : 
     268           0 : bool UDTLayoutBase::hasVBPtrAtOffset(uint32_t Off) const {
     269           0 :   if (VBPtr && VBPtr->getOffsetInParent() == Off)
     270             :     return true;
     271           0 :   for (BaseClassLayout *BL : AllBases) {
     272           0 :     if (BL->hasVBPtrAtOffset(Off - BL->getOffsetInParent()))
     273             :       return true;
     274             :   }
     275             :   return false;
     276             : }
     277             : 
     278           0 : void UDTLayoutBase::addChildToLayout(std::unique_ptr<LayoutItemBase> Child) {
     279           0 :   uint32_t Begin = Child->getOffsetInParent();
     280             : 
     281           0 :   if (!Child->isElided()) {
     282           0 :     BitVector ChildBytes = Child->usedBytes();
     283             : 
     284             :     // Suppose the child occupies 4 bytes starting at offset 12 in a 32 byte
     285             :     // class.  When we call ChildBytes.resize(32), the Child's storage will
     286             :     // still begin at offset 0, so we need to shift it left by offset bytes
     287             :     // to get it into the right position.
     288           0 :     ChildBytes.resize(UsedBytes.size());
     289           0 :     ChildBytes <<= Child->getOffsetInParent();
     290           0 :     UsedBytes |= ChildBytes;
     291             : 
     292           0 :     if (ChildBytes.count() > 0) {
     293             :       auto Loc = std::upper_bound(LayoutItems.begin(), LayoutItems.end(), Begin,
     294             :                                   [](uint32_t Off, const LayoutItemBase *Item) {
     295           0 :                                     return (Off < Item->getOffsetInParent());
     296           0 :                                   });
     297             : 
     298           0 :       LayoutItems.insert(Loc, Child.get());
     299             :     }
     300             :   }
     301             : 
     302           0 :   ChildStorage.push_back(std::move(Child));
     303           0 : }

Generated by: LCOV version 1.13