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;
isBitFieldField32     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.
getDecl()52   const RecordDecl *getDecl() const { return Decl; }
53   /// Returns the name of the underlying declaration.
getName()54   const std::string getName() const { return Decl->getNameAsString(); }
55   /// Checks if the record is a union.
isUnion()56   bool isUnion() const { return getDecl()->isUnion(); }
57   /// Returns the size of the record.
getSize()58   unsigned getSize() const { return BaseSize; }
59   /// Returns the full size of the record, including records.
getFullSize()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.
getDestructor()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;
fields()77   llvm::iterator_range<const_field_iter> fields() const {
78     return llvm::make_range(Fields.begin(), Fields.end());
79   }
80 
getNumFields()81   unsigned getNumFields() const { return Fields.size(); }
getField(unsigned I)82   const Field *getField(unsigned I) const { return &Fields[I]; }
getField(unsigned I)83   Field *getField(unsigned I) { return &Fields[I]; }
84 
85   using const_base_iter = BaseList::const_iterator;
bases()86   llvm::iterator_range<const_base_iter> bases() const {
87     return llvm::make_range(Bases.begin(), Bases.end());
88   }
89 
getNumBases()90   unsigned getNumBases() const { return Bases.size(); }
getBase(unsigned I)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;
virtual_bases()97   llvm::iterator_range<const_virtual_iter> virtual_bases() const {
98     return llvm::make_range(VirtualBases.begin(), VirtualBases.end());
99   }
100 
getNumVirtualBases()101   unsigned getNumVirtualBases() const { return VirtualBases.size(); }
getVirtualBase(unsigned I)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
138