llvm/clang/lib/AST/ByteCode/Descriptor.cpp

//===--- Descriptor.cpp - 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
//
//===----------------------------------------------------------------------===//

#include "Descriptor.h"
#include "Boolean.h"
#include "FixedPoint.h"
#include "Floating.h"
#include "FunctionPointer.h"
#include "IntegralAP.h"
#include "MemberPointer.h"
#include "Pointer.h"
#include "PrimType.h"
#include "Record.h"
#include "Source.h"

usingnamespaceclang;
usingnamespaceclang::interp;

template <typename T>
static void ctorTy(Block *, std::byte *Ptr, bool, bool, bool, bool,
                   const Descriptor *) { … }

template <typename T>
static void dtorTy(Block *, std::byte *Ptr, const Descriptor *) { … }

template <typename T>
static void moveTy(Block *, std::byte *Src, std::byte *Dst,
                   const Descriptor *) { … }

template <typename T>
static void ctorArrayTy(Block *, std::byte *Ptr, bool, bool, bool, bool,
                        const Descriptor *D) { … }

template <typename T>
static void dtorArrayTy(Block *, std::byte *Ptr, const Descriptor *D) { … }

template <typename T>
static void moveArrayTy(Block *, std::byte *Src, std::byte *Dst,
                        const Descriptor *D) { … }

static void ctorArrayDesc(Block *B, std::byte *Ptr, bool IsConst,
                          bool IsMutable, bool IsActive, bool InUnion,
                          const Descriptor *D) { … }

static void dtorArrayDesc(Block *B, std::byte *Ptr, const Descriptor *D) { … }

static void moveArrayDesc(Block *B, std::byte *Src, std::byte *Dst,
                          const Descriptor *D) { … }

static void initField(Block *B, std::byte *Ptr, bool IsConst, bool IsMutable,
                      bool IsActive, bool IsUnionField, bool InUnion,
                      const Descriptor *D, unsigned FieldOffset) { … }

static void initBase(Block *B, std::byte *Ptr, bool IsConst, bool IsMutable,
                     bool IsActive, bool InUnion, const Descriptor *D,
                     unsigned FieldOffset, bool IsVirtualBase) { … }

static void ctorRecord(Block *B, std::byte *Ptr, bool IsConst, bool IsMutable,
                       bool IsActive, bool InUnion, const Descriptor *D) { … }

static void destroyField(Block *B, std::byte *Ptr, const Descriptor *D,
                         unsigned FieldOffset) { … }

static void destroyBase(Block *B, std::byte *Ptr, const Descriptor *D,
                        unsigned FieldOffset) { … }

static void dtorRecord(Block *B, std::byte *Ptr, const Descriptor *D) { … }

static void moveRecord(Block *B, std::byte *Src, std::byte *Dst,
                       const Descriptor *D) { … }

static BlockCtorFn getCtorPrim(PrimType Type) { … }

static BlockDtorFn getDtorPrim(PrimType Type) { … }

static BlockMoveFn getMovePrim(PrimType Type) { … }

static BlockCtorFn getCtorArrayPrim(PrimType Type) { … }

static BlockDtorFn getDtorArrayPrim(PrimType Type) { … }

static BlockMoveFn getMoveArrayPrim(PrimType Type) { … }

/// Primitives.
Descriptor::Descriptor(const DeclTy &D, PrimType Type, MetadataSize MD,
                       bool IsConst, bool IsTemporary, bool IsMutable)
    : … { … }

/// Primitive arrays.
Descriptor::Descriptor(const DeclTy &D, PrimType Type, MetadataSize MD,
                       size_t NumElems, bool IsConst, bool IsTemporary,
                       bool IsMutable)
    : … { … }

/// Primitive unknown-size arrays.
Descriptor::Descriptor(const DeclTy &D, PrimType Type, MetadataSize MD,
                       bool IsTemporary, UnknownSize)
    : … { … }

/// Arrays of composite elements.
Descriptor::Descriptor(const DeclTy &D, const Descriptor *Elem, MetadataSize MD,
                       unsigned NumElems, bool IsConst, bool IsTemporary,
                       bool IsMutable)
    : … { … }

/// Unknown-size arrays of composite elements.
Descriptor::Descriptor(const DeclTy &D, const Descriptor *Elem, MetadataSize MD,
                       bool IsTemporary, UnknownSize)
    : … { … }

/// Composite records.
Descriptor::Descriptor(const DeclTy &D, const Record *R, MetadataSize MD,
                       bool IsConst, bool IsTemporary, bool IsMutable)
    : … { … }

/// Dummy.
Descriptor::Descriptor(const DeclTy &D)
    : … { … }

QualType Descriptor::getType() const { … }

QualType Descriptor::getElemQualType() const { … }

SourceLocation Descriptor::getLocation() const { … }

SourceInfo Descriptor::getLoc() const { … }

bool Descriptor::isUnion() const { … }

InitMap::InitMap(unsigned N)
    : … { … }

bool InitMap::initializeElement(unsigned I) { … }

bool InitMap::isElementInitialized(unsigned I) const { … }