Descriptor.h

Go to the documentation of this file.

//===--- Descriptor.h - Types for the constexpr 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
//
//===----------------------------------------------------------------------===//
//
// Defines descriptors which characterise allocations.
//
//===----------------------------------------------------------------------===//
 
#ifndef LLVM_CLANG_AST_INTERP_DESCRIPTOR_H
#define LLVM_CLANG_AST_INTERP_DESCRIPTOR_H
 
#include "../ExprConstShared.h"
#include "DeclOrExpr.h"
#include "InitMap.h"
#include "PrimType.h"
#include "clang/AST/Decl.h"
#include "clang/AST/Expr.h"
 
namespace clang {
namespace interp {
class Record;
class SourceInfo;
struct Descriptor;
enum PrimType : uint8_t;
 
/// Invoked whenever a block is created. The constructor method fills in the
/// inline descriptors of all fields and array elements. It also initializes
/// all the fields which contain non-trivial types.
using BlockCtorFn = void (*)(std::byte *FieldPtr, bool IsConst, bool IsMutable,
                             bool IsVolatile, bool IsActive, bool InUnion,
                             const Descriptor *FieldDesc);
 
/// Invoked when a block is destroyed. Invokes the destructors of all
/// non-trivial nested fields of arrays and records.
using BlockDtorFn = void (*)(std::byte *FieldPtr, const Descriptor *FieldDesc);
 
enum class GlobalInitState {
  Initialized,
  NoInitializer,
  InitializerFailed,
};
 
/// Descriptor used for global variables.
struct alignas(void *) GlobalInlineDescriptor {
  GlobalInitState InitState = GlobalInitState::InitializerFailed;
};
static_assert(sizeof(GlobalInlineDescriptor) == sizeof(void *), "");
 
enum class Lifetime : uint8_t {
  Started,
  NotStarted,
  Destroyed,
  Ended,
};
 
struct alignas(void *) LocalInlineDescriptor {
  bool IsEnabled;
  bool IsInitialized;
  Lifetime LifeState;
 
  LocalInlineDescriptor()
      : IsEnabled(false), IsInitialized(false), LifeState(Lifetime::Started) {}
  Lifetime getLifetime() const { return LifeState; }
  void setLifetime(Lifetime L) { LifeState = L; }
};
static_assert(sizeof(LocalInlineDescriptor) == sizeof(void *));
 
/// Inline descriptor embedded in structures and arrays.
///
/// Such descriptors precede all composite array elements and structure fields.
/// If the base of a pointer is not zero, the base points to the end of this
/// structure. The offset field is used to traverse the pointer chain up
/// to the root structure which allocated the object.
struct InlineDescriptor {
  /// Offset inside the structure/array.
  unsigned Offset;
 
  /// Flag indicating if the storage is constant or not.
  /// Relevant for primitive fields.
  LLVM_PREFERRED_TYPE(bool)
  unsigned IsConst : 1;
  /// For primitive fields, it indicates if the field was initialized.
  /// Primitive fields in static storage are always initialized.
  /// Arrays are always initialized, even though their elements might not be.
  /// Base classes are initialized after the constructor is invoked.
  LLVM_PREFERRED_TYPE(bool)
  unsigned IsInitialized : 1;
  /// Flag indicating if the field is an embedded base class.
  LLVM_PREFERRED_TYPE(bool)
  unsigned IsBase : 1;
  /// Flag inidcating if the field is a virtual base class.
  LLVM_PREFERRED_TYPE(bool)
  unsigned IsVirtualBase : 1;
  /// Flag indicating if the field is the active member of a union.
  LLVM_PREFERRED_TYPE(bool)
  unsigned IsActive : 1;
  /// Flag indicating if this field is in a union (even if nested).
  LLVM_PREFERRED_TYPE(bool)
  unsigned InUnion : 1;
  /// Flag indicating if the field is mutable (if in a record).
  LLVM_PREFERRED_TYPE(bool)
  unsigned IsFieldMutable : 1;
  /// Flag indicating if this field is a const field nested in
  /// a mutable parent field.
  LLVM_PREFERRED_TYPE(bool)
  unsigned IsConstInMutable : 1;
  /// Flag indicating if the field is an element of a composite array.
  LLVM_PREFERRED_TYPE(bool)
  unsigned IsArrayElement : 1;
  LLVM_PREFERRED_TYPE(bool)
  unsigned IsVolatile : 1;
 
  Lifetime LifeState;
 
  const Descriptor *Desc;
 
  void dump() const { dump(llvm::errs()); }
  void dump(llvm::raw_ostream &OS) const;
};
 
/// Describes a memory block created by an allocation site.
struct Descriptor final {
private:
  /// Original declaration, used to emit the error message.
  const DeclOrExpr Source;
  const Type *SourceType = nullptr;
  /// Size of an element, in host bytes.
  const unsigned ElemSize;
  /// Size of the storage, in host bytes.
  const unsigned Size;
  /// Size of the allocation (storage), in host bytes.
  const unsigned AllocSize;
 
  /// Value to denote arrays of unknown size.
  static constexpr unsigned UnknownSizeMark = (unsigned)-1;
 
public:
  /// Token to denote structures of unknown size.
  struct UnknownSize {};
 
  /// Maximum number of bytes to be used for array elements.
  static constexpr unsigned MaxArrayElemBytes =
      std::numeric_limits<decltype(AllocSize)>::max() - sizeof(InitMapPtr);
 
  /// Pointer to the record, if block contains records.
  const Record *const ElemRecord = nullptr;
  /// Descriptor of the array element.
  const Descriptor *const ElemDesc = nullptr;
  /// The primitive type this descriptor was created for,
  /// or the primitive element type in case this is
  /// a primitive array.
  const OptPrimType PrimT = std::nullopt;
  /// Flag indicating if the block is mutable.
  const bool IsConst = false;
  /// Flag indicating if a field is mutable.
  const bool IsMutable = false;
  /// Flag indicating if the block is a temporary.
  const bool IsTemporary = false;
  const bool IsVolatile = false;
  /// Flag indicating if the block is an array.
  const bool IsArray = false;
 
  /// Storage management methods.
  const BlockCtorFn CtorFn = nullptr;
  const BlockDtorFn DtorFn = nullptr;
 
  /// Allocates a descriptor for a primitive.
  Descriptor(DeclOrExpr D, const Type *SourceTy, PrimType Type, bool IsConst,
             bool IsTemporary, bool IsMutable, bool IsVolatile);
 
  /// Allocates a descriptor for an array of primitives.
  Descriptor(DeclOrExpr D, const Type *SourceTy, PrimType Type, size_t NumElems,
             bool IsConst, bool IsTemporary, bool IsMutable, bool IsVolatile);
 
  /// Allocates a descriptor for an array of primitives of unknown size.
  Descriptor(DeclOrExpr D, PrimType Type, bool IsConst, bool IsTemporary,
             UnknownSize);
 
  /// Allocates a descriptor for an array of composites.
  Descriptor(DeclOrExpr D, const Type *SourceTy, const Descriptor *Elem,
             unsigned NumElems, bool IsConst, bool IsTemporary, bool IsMutable);
 
  /// Allocates a descriptor for an array of composites of unknown size.
  Descriptor(DeclOrExpr D, const Descriptor *Elem, bool IsTemporary,
             UnknownSize);
 
  /// Allocates a descriptor for a record.
  Descriptor(DeclOrExpr D, const Record *R, bool IsConst, bool IsTemporary,
             bool IsMutable, bool IsVolatile);
 
  /// Allocates a dummy descriptor.
  Descriptor(DeclOrExpr D);
 
  QualType getType() const;
  QualType getElemQualType() const;
  QualType getDataType(const ASTContext &Ctx) const;
  SourceLocation getLocation() const { return Source.getLocation(); }
  SourceInfo getLoc() const;
 
  const Decl *asDecl() const { return Source.asDecl(); }
  const Expr *asExpr() const { return Source.asExpr(); }
  DeclOrExpr getSource() const { return Source; }
 
  const ValueDecl *asValueDecl() const {
    return dyn_cast_if_present<ValueDecl>(asDecl());
  }
 
  const VarDecl *asVarDecl() const {
    return dyn_cast_if_present<VarDecl>(asDecl());
  }
 
  const FieldDecl *asFieldDecl() const {
    return dyn_cast_if_present<FieldDecl>(asDecl());
  }
 
  const RecordDecl *asRecordDecl() const {
    return dyn_cast_if_present<RecordDecl>(asDecl());
  }
 
  template <typename T> const T *getAs() const {
    return dyn_cast_if_present<T>(asDecl());
  }
 
  /// Returns the size of the object without metadata.
  unsigned getSize() const {
    assert(!isUnknownSizeArray() && "Array of unknown size");
    return Size;
  }
 
  PrimType getPrimType() const {
    assert(isPrimitiveArray() || isPrimitive());
    return *PrimT;
  }
 
  /// Returns the allocated size, including metadata.
  unsigned getAllocSize() const { return AllocSize; }
  /// returns the size of an element when the structure is viewed as an array.
  unsigned getElemSize() const { return ElemSize; }
  /// Returns the element data size, i.e. not what the size of
  /// our primitive data type is, but what the data size of that is.
  /// E.g., for PT_SInt32, that's 4 bytes.
  unsigned getElemDataSize() const;
 
  /// Returns the number of elements stored in the block.
  unsigned getNumElems() const {
    return Size == UnknownSizeMark ? 0 : (getSize() / getElemSize());
  }
 
  /// Checks if the descriptor is of an array of primitives.
  bool isPrimitiveArray() const { return IsArray && !ElemDesc; }
  /// Checks if the descriptor is of an array of composites.
  bool isCompositeArray() const { return IsArray && ElemDesc; }
  /// Checks if the descriptor is of an array of zero size.
  bool isZeroSizeArray() const { return Size == 0; }
  /// Checks if the descriptor is of an array of unknown size.
  bool isUnknownSizeArray() const { return Size == UnknownSizeMark; }
 
  /// Checks if the descriptor is of a primitive.
  bool isPrimitive() const { return !IsArray && !ElemRecord && PrimT; }
 
  /// Checks if the descriptor is of an array.
  bool isArray() const { return IsArray; }
  /// Checks if the descriptor is of a record.
  bool isRecord() const { return !IsArray && ElemRecord; }
  /// Checks if the descriptor is of a union.
  bool isUnion() const;
 
  /// Whether variables of this descriptor need their destructor called or not.
  bool hasTrivialDtor() const;
 
  /// Returns the kind of dynamic allocation source of this block.
  static DynAllocKind getDynAllocKindForExpr(const Expr *E);
  /// Returns the kind of dynamic allocation source of this block.
  DynAllocKind getDynAllocKind() const {
    return asExpr() ? getDynAllocKindForExpr(asExpr()) : DynAllocKind::None;
  }
  /// Checks if the descriptor is of a dynamic allocation.
  bool isDynAlloc() const { return getDynAllocKind() != DynAllocKind::None; }
 
  /// Compute the alignment for a dynamic allocation.
  CharUnits computeAlignForDynamicAlloc(const ASTContext &Ctx) const;
 
  void dump() const;
  void dump(llvm::raw_ostream &OS) const;
  void dumpFull(unsigned Offset = 0, unsigned Indent = 0) const;
};
} // namespace interp
} // namespace clang
 
#endif