Record.h

Go to the documentation of this file.

//===--- Record.h - struct and class metadata for the VM --------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// A record is part of a program to describe the layout and methods of a struct.
//
//===----------------------------------------------------------------------===//
 
#ifndef LLVM_CLANG_AST_INTERP_RECORD_H
#define LLVM_CLANG_AST_INTERP_RECORD_H
 
#include "PrimType.h"
#include "clang/AST/Decl.h"
#include "clang/AST/DeclCXX.h"
 
namespace clang {
namespace interp {
class Program;
struct Descriptor;
 
/// Structure/Class descriptor.
class Record final {
public:
  /// Describes a record field.
  struct Field {
    const FieldDecl *Decl;
    const Descriptor *Desc;
    unsigned Offset;
    OptPrimType T;
    bool IsBitField;
    bool IsUnnamedBitField;
 
    bool isBitField() const { return IsBitField; }
    bool isUnnamedBitField() const { return IsUnnamedBitField; }
    unsigned bitWidth() const {
      assert(isBitField());
      return Decl->getBitWidthValue();
    }
 
    Field(const FieldDecl *D, const Descriptor *Desc, unsigned Offset,
          OptPrimType T)
        : Decl(D), Desc(Desc), Offset(Offset), T(T) {
      IsBitField = Decl->isBitField();
      IsUnnamedBitField = IsBitField && Decl->isUnnamedBitField();
    }
  };
 
  /// Describes a base class.
  struct Base {
    const RecordDecl *Decl;
    const Descriptor *Desc;
    const Record *R;
    unsigned Offset;
 
    Base(const RecordDecl *D, const Descriptor *Desc, const Record *R,
         unsigned Offset)
        : Decl(D), Desc(Desc), R(R), Offset(Offset) {}
  };
 
  /// Mapping from identifiers to field descriptors.
  using FieldList = llvm::SmallVector<Field, 8>;
  /// Mapping from identifiers to base classes.
  using BaseList = llvm::SmallVector<Base, 8>;
  /// List of virtual base classes.
  using VirtualBaseList = llvm::SmallVector<Base, 0>;
 
public:
  /// Returns the underlying declaration.
  const RecordDecl *getDecl() const { return Decl; }
  /// Returns the name of the underlying declaration.
  std::string getName() const;
  /// Checks if the record is a union.
  bool isUnion() const { return IsUnion; }
  /// Checks if the record is an anonymous union.
  bool isAnonymousUnion() const { return IsAnonymousUnion; }
  /// Returns the size of the record.
  unsigned getSize() const { return BaseSize; }
  /// Returns the full size of the record, including records.
  unsigned getFullSize() const { return BaseSize + VirtualSize; }
  /// Returns the destructor of the record, if any.
  const CXXDestructorDecl *getDestructor() const {
    if (const auto *CXXDecl = dyn_cast<CXXRecordDecl>(Decl))
      return CXXDecl->getDestructor();
    return nullptr;
  }
  /// If this record (or any of its bases) contains a field of type PT_Ptr.
  bool hasPtrField() const { return HasPtrField; }
 
  /// Returns true for anonymous unions and records
  /// with no destructor or for those with a trivial destructor.
  bool hasTrivialDtor() const;
 
  using const_field_iter = FieldList::const_iterator;
  llvm::iterator_range<const_field_iter> fields() const {
    return llvm::make_range(Fields.begin(), Fields.end());
  }
 
  unsigned getNumFields() const { return Fields.size(); }
  const Field *getField(unsigned I) const { return &Fields[I]; }
  /// Find a field with the given offset.
  /// This does a linear search, so use sparingly.
  const Field *findField(unsigned Offset) const;
  /// Returns a field.
  const Field *getField(const FieldDecl *FD) const {
    return &Fields[FD->getFieldIndex()];
  }
 
  using const_base_iter = BaseList::const_iterator;
  llvm::iterator_range<const_base_iter> bases() const {
    return llvm::make_range(Bases.begin(), Bases.end());
  }
 
  unsigned getNumBases() const { return Bases.size(); }
  const Base *getBase(unsigned I) const {
    assert(I < getNumBases());
    return &Bases[I];
  }
  /// Returns a base descriptor.
  const Base *getBase(QualType T) const;
  /// Returns a base descriptor.
  const Base *getBase(const RecordDecl *RD) const;
  const Base *getBaseOrNull(const RecordDecl *RD) const;
  const Base *findBase(unsigned Offset) const;
 
  using const_virtual_iter = VirtualBaseList::const_iterator;
  llvm::iterator_range<const_virtual_iter> virtual_bases() const {
    return llvm::make_range(VirtualBases.begin(), VirtualBases.end());
  }
 
  unsigned getNumVirtualBases() const { return VirtualBases.size(); }
  const Base *getVirtualBase(unsigned I) const { return &VirtualBases[I]; }
  /// Returns a virtual base descriptor.
  const Base *findVirtualBase(const RecordDecl *RD) const;
 
  void dump(llvm::raw_ostream &OS, unsigned Indentation = 0,
            unsigned Offset = 0) const;
  void dump() const { dump(llvm::errs()); }
 
private:
  /// Constructor used by Program to create record descriptors.
  Record(const RecordDecl *, BaseList &&Bases, FieldList &&Fields,
         VirtualBaseList &&VirtualBases, unsigned VirtualSize,
         unsigned BaseSize, bool HasPtrField = true);
 
private:
  friend class Program;
 
  /// Original declaration.
  const RecordDecl *Decl;
  /// List of all base classes.
  BaseList Bases;
  /// List of all the fields in the record.
  FieldList Fields;
  /// List of all virtual bases.
  VirtualBaseList VirtualBases;
 
  /// Mapping from declarations to bases.
  llvm::DenseMap<const RecordDecl *, const Base *> BaseMap;
  /// Size of the structure.
  unsigned BaseSize;
  /// Size of all virtual bases.
  unsigned VirtualSize;
  /// If this record is a union.
  bool IsUnion;
  /// If this is an anonymous union.
  bool IsAnonymousUnion;
  /// If any of the fields are pointers (or references).
  bool HasPtrField = false;
};
 
} // namespace interp
} // namespace clang
 
#endif