MemberPointer.h

Go to the documentation of this file.

//===------------------------- MemberPointer.h ------------------*- 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
//
//===----------------------------------------------------------------------===//
 
#ifndef LLVM_CLANG_AST_INTERP_MEMBER_POINTER_H
#define LLVM_CLANG_AST_INTERP_MEMBER_POINTER_H
 
#include "Pointer.h"
#include "llvm/ADT/PointerIntPair.h"
#include <optional>
 
namespace clang {
class ASTContext;
class CXXRecordDecl;
namespace interp {
 
class Context;
 
class MemberPointer final {
private:
  Pointer Base;
  /// The member declaration, and a flag indicating
  /// whether the member is a member of some class derived from the class type
  /// of the member pointer.
  llvm::PointerIntPair<const ValueDecl *, 1, bool> DeclAndIsDerivedMember;
  /// The path of base/derived classes from the member declaration's
  /// class (exclusive) to the class type of the member pointer (inclusive).
  /// This a allocated by the InterpState or the Program.
  const CXXRecordDecl **Path = nullptr;
  int32_t PtrOffset = 0;
  uint8_t PathLength = 0;
 
  MemberPointer(Pointer Base, const ValueDecl *Dcl, int32_t PtrOffset,
                uint8_t PathLength = 0, const CXXRecordDecl **Path = nullptr,
                bool IsDerived = false)
      : Base(Base), DeclAndIsDerivedMember(Dcl, IsDerived), Path(Path),
        PtrOffset(PtrOffset), PathLength(PathLength) {}
 
public:
  MemberPointer() = default;
  MemberPointer(Pointer Base, const ValueDecl *Dcl)
      : Base(Base), DeclAndIsDerivedMember(Dcl) {}
  MemberPointer(uint32_t Address, const Descriptor *D) {
    // We only reach this for Address == 0, when creating a null member pointer.
    assert(Address == 0);
  }
 
  MemberPointer(const ValueDecl *D) : DeclAndIsDerivedMember(D) {
    assert((isa<FieldDecl, IndirectFieldDecl, CXXMethodDecl>(D)));
  }
 
  uint64_t getIntegerRepresentation() const {
    assert(
        false &&
        "getIntegerRepresentation() shouldn't be reachable for MemberPointers");
    return 17;
  }
 
  /// Does this member pointer have a base declaration?
  bool hasDecl() const { return DeclAndIsDerivedMember.getPointer(); }
  bool isDerivedMember() const { return DeclAndIsDerivedMember.getInt(); }
  /// Return the base declaration. Might be null.
  const ValueDecl *getDecl() const {
    return DeclAndIsDerivedMember.getPointer();
  }
  /// Does this member pointer have a path (i.e. path length is > 0)?
  bool hasPath() const { return PathLength != 0; }
  /// Return the length of the cast path.
  unsigned getPathLength() const { return PathLength; }
  /// Return the cast path entry at the given position.
  const CXXRecordDecl *getPathEntry(unsigned Index) const {
    assert(Index < PathLength);
    return Path[Index];
  }
  /// Return the cast path. Might return null.
  const CXXRecordDecl **path() const { return Path; }
  bool isZero() const { return Base.isZero() && !hasDecl(); }
  bool hasBase() const { return !Base.isZero(); }
  bool isWeak() const {
    if (const auto *MF = getMemberFunction())
      return MF->isWeak();
    return false;
  }
 
  /// Sets the path of this member pointer. After this call,
  /// the memory pointed to by \p NewPath is assumed to be owned
  /// by this member pointer.
  void takePath(const CXXRecordDecl **NewPath) {
    assert(Path != NewPath);
    Path = NewPath;
  }
 
  // Pretend we always have a path.
  bool singleWord() const { return false; }
  ComparisonCategoryResult compare(const MemberPointer &RHS) const;
 
  std::optional<Pointer> toPointer(const Context &Ctx) const;
 
  bool isBaseCastPossible() const {
    if (PtrOffset < 0)
      return true;
    return static_cast<uint64_t>(PtrOffset) <= Base.getByteOffset();
  }
 
  Pointer getBase() const {
    if (PtrOffset < 0)
      return Base.atField(-PtrOffset);
    return Base.atFieldSub(PtrOffset);
  }
  /// Is the base declaration a member function?
  bool isMemberFunctionPointer() const {
    return isa_and_nonnull<CXXMethodDecl>(DeclAndIsDerivedMember.getPointer());
  }
  /// Return the base declaration as a CXXMethodDecl. Might return null.
  const CXXMethodDecl *getMemberFunction() const {
    return dyn_cast_if_present<CXXMethodDecl>(
        DeclAndIsDerivedMember.getPointer());
  }
  /// Return the base declaration as a FieldDecl. Might return null.
  const FieldDecl *getField() const {
    return dyn_cast_if_present<FieldDecl>(DeclAndIsDerivedMember.getPointer());
  }
  /// Returns the record decl this member pointer points into.
  const CXXRecordDecl *getRecordDecl() const {
    if (const FieldDecl *FD = getField())
      return cast<CXXRecordDecl>(FD->getParent());
 
    if (const CXXMethodDecl *MD = getMemberFunction())
      return MD->getParent();
    return nullptr;
  }
 
  MemberPointer atInstanceBase(unsigned Offset, uint8_t PathLength = 0,
                               const CXXRecordDecl **Path = nullptr,
                               bool NewIsDerived = false) const {
    if (Base.isZero())
      return MemberPointer(Base, DeclAndIsDerivedMember.getPointer(), Offset,
                           PathLength, Path, NewIsDerived);
    return MemberPointer(this->Base, DeclAndIsDerivedMember.getPointer(),
                         Offset + PtrOffset, PathLength, Path, NewIsDerived);
  }
 
  MemberPointer takeInstance(Pointer Instance) const {
    assert(this->Base.isZero());
    return MemberPointer(Instance, DeclAndIsDerivedMember.getPointer(),
                         this->PtrOffset);
  }
 
  APValue toAPValue(const ASTContext &) const;
 
  void print(llvm::raw_ostream &OS) const {
    OS << "MemberPtr(" << Base << " " << (const void *)getDecl() << " + "
       << PtrOffset << ". PathLength: " << getPathLength()
       << ". IsDerived: " << isDerivedMember() << ")";
  }
 
  std::string toDiagnosticString(const ASTContext &Ctx) const {
    return toAPValue(Ctx).getAsString(Ctx, getDecl()->getType());
  }
};
 
inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
                                     const MemberPointer &FP) {
  FP.print(OS);
  return OS;
}
 
} // namespace interp
} // namespace clang
 
#endif