clang/lib/AST/Interp/Record.h

   1 //===--- Record.h - struct and class metadata for the VM --------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // A record is part of a program to describe the layout and methods of a struct.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #ifndef LLVM_CLANG_AST_INTERP_RECORD_H
  14 #define LLVM_CLANG_AST_INTERP_RECORD_H
  15
  16 #include "Descriptor.h"
  17 #include "clang/AST/Decl.h"
  18 #include "clang/AST/DeclCXX.h"
  19
  20 namespace clang {
  21 namespace interp {
  22 class Program;
  23
  24 /// Structure/Class descriptor.
  25 class Record final {
  26 public:
  27   /// Describes a record field.
  28   struct Field {
  29     const FieldDecl *Decl;
  30     unsigned Offset;
  31     Descriptor *Desc;
  32     bool isBitField() const { return Decl->isBitField(); }
  33   };
  34
  35   /// Describes a base class.
  36   struct Base {
  37     const RecordDecl *Decl;
  38     unsigned Offset;
  39     Descriptor *Desc;
  40     Record *R;
  41   };
  42
  43   /// Mapping from identifiers to field descriptors.
  44   using FieldList = llvm::SmallVector<Field, 8>;
  45   /// Mapping from identifiers to base classes.
  46   using BaseList = llvm::SmallVector<Base, 8>;
  47   /// List of virtual base classes.
  48   using VirtualBaseList = llvm::SmallVector<Base, 2>;
  49
  50 public:
  51   /// Returns the underlying declaration.
  52   const RecordDecl *getDecl() const { return Decl; }
  53   /// Returns the name of the underlying declaration.
  54   const std::string getName() const { return Decl->getNameAsString(); }
  55   /// Checks if the record is a union.
  56   bool isUnion() const { return getDecl()->isUnion(); }
  57   /// Returns the size of the record.
  58   unsigned getSize() const { return BaseSize; }
  59   /// Returns the full size of the record, including records.
  60   unsigned getFullSize() const { return BaseSize + VirtualSize; }
  61   /// Returns a field.
  62   const Field *getField(const FieldDecl *FD) const;
  63   /// Returns a base descriptor.
  64   const Base *getBase(const RecordDecl *FD) const;
  65   /// Returns a base descriptor.
  66   const Base *getBase(QualType T) const;
  67   /// Returns a virtual base descriptor.
  68   const Base *getVirtualBase(const RecordDecl *RD) const;
  69   /// Returns the destructor of the record, if any.
  70   const CXXDestructorDecl *getDestructor() const {
  71     if (const auto *CXXDecl = dyn_cast<CXXRecordDecl>(Decl))
  72       return CXXDecl->getDestructor();
  73     return nullptr;
  74   }
  75
  76   using const_field_iter = FieldList::const_iterator;
  77   llvm::iterator_range<const_field_iter> fields() const {
  78     return llvm::make_range(Fields.begin(), Fields.end());
  79   }
  80
  81   unsigned getNumFields() const { return Fields.size(); }
  82   const Field *getField(unsigned I) const { return &Fields[I]; }
  83   Field *getField(unsigned I) { return &Fields[I]; }
  84
  85   using const_base_iter = BaseList::const_iterator;
  86   llvm::iterator_range<const_base_iter> bases() const {
  87     return llvm::make_range(Bases.begin(), Bases.end());
  88   }
  89
  90   unsigned getNumBases() const { return Bases.size(); }
  91   const Base *getBase(unsigned I) const {
  92     assert(I < getNumBases());
  93     return &Bases[I];
  94   }
  95
  96   using const_virtual_iter = VirtualBaseList::const_iterator;
  97   llvm::iterator_range<const_virtual_iter> virtual_bases() const {
  98     return llvm::make_range(VirtualBases.begin(), VirtualBases.end());
  99   }
 100
 101   unsigned getNumVirtualBases() const { return VirtualBases.size(); }
 102   const Base *getVirtualBase(unsigned I) const { return &VirtualBases[I]; }
 103
 104 private:
 105   /// Constructor used by Program to create record descriptors.
 106   Record(const RecordDecl *, BaseList &&Bases, FieldList &&Fields,
 107          VirtualBaseList &&VirtualBases, unsigned VirtualSize,
 108          unsigned BaseSize);
 109
 110 private:
 111   friend class Program;
 112
 113   /// Original declaration.
 114   const RecordDecl *Decl;
 115   /// List of all base classes.
 116   BaseList Bases;
 117   /// List of all the fields in the record.
 118   FieldList Fields;
 119   /// List o fall virtual bases.
 120   VirtualBaseList VirtualBases;
 121
 122   /// Mapping from declarations to bases.
 123   llvm::DenseMap<const RecordDecl *, Base *> BaseMap;
 124   /// Mapping from field identifiers to descriptors.
 125   llvm::DenseMap<const FieldDecl *, Field *> FieldMap;
 126   /// Mapping from declarations to virtual bases.
 127   llvm::DenseMap<const RecordDecl *, Base *> VirtualBaseMap;
 128   /// Size of the structure.
 129   unsigned BaseSize;
 130   /// Size of all virtual bases.
 131   unsigned VirtualSize;
 132 };
 133
 134 } // namespace interp
 135 } // namespace clang
 136
 137 #endif