lib/AST/ByteCode/DynamicAllocator.h

//==--------- DynamicAllocator.h - Dynamic allocations ------------*- 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_DYNAMIC_ALLOCATOR_H
#define LLVM_CLANG_AST_INTERP_DYNAMIC_ALLOCATOR_H

#include "Descriptor.h"
#include "InterpBlock.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/iterator_range.h"
#include "llvm/Support/Allocator.h"

namespace clang {
class Expr;
namespace interp {
class Block;
class InterpState;

/// Manages dynamic memory allocations done during bytecode interpretation.
///
/// We manage allocations as a map from their new-expression to a list
/// of allocations. This is called an AllocationSite. For each site, we
/// record whether it was allocated using new or new[], the
/// IsArrayAllocation flag.
///
/// For all array allocations, we need to allocate new Descriptor instances,
/// so the DynamicAllocator has a llvm::BumpPtrAllocator similar to Program.
class DynamicAllocator final {
public:
  enum class Form : uint8_t {
    NonArray,
    Array,
    Operator,
  };

private:
  struct Allocation {
    std::unique_ptr<std::byte[]> Memory;
    Allocation(std::unique_ptr<std::byte[]> Memory)
        : Memory(std::move(Memory)) {}
    Block *block() const { return reinterpret_cast<Block *>(Memory.get()); }
  };

  struct AllocationSite {
    llvm::SmallVector<Allocation> Allocations;
    unsigned NumAllocs = 0;
    Form AllocForm;

    AllocationSite(std::unique_ptr<std::byte[]> Memory, Form AllocForm)
        : AllocForm(AllocForm) {
      Allocations.push_back({std::move(Memory)});
      ++NumAllocs;
    }

    size_t size() const { return Allocations.size(); }
    bool empty() const { return Allocations.empty(); }
  };

public:
  DynamicAllocator() = default;
  DynamicAllocator(DynamicAllocator &) = delete;
  DynamicAllocator(DynamicAllocator &&) = delete;
  ~DynamicAllocator();

  void cleanup();

  /// Allocate ONE element of the given descriptor.
  Block *allocate(const Descriptor *D, unsigned EvalID, Form AllocForm);
  /// Allocate \p NumElements primitive elements of the given type.
  Block *allocate(const Expr *Source, PrimType T, size_t NumElements,
                  unsigned EvalID, Form AllocForm);
  /// Allocate \p NumElements elements of the given descriptor.
  Block *allocate(const Descriptor *D, size_t NumElements, unsigned EvalID,
                  Form AllocForm);

  /// Deallocate the given source+block combination.
  /// Returns \c true if anything has been deallocatd, \c false otherwise.
  bool deallocate(const Expr *Source, const Block *BlockToDelete,
                  InterpState &S);

  /// Checks whether the allocation done at the given source is an array
  /// allocation.
  std::optional<Form> getAllocationForm(const Expr *Source) const {
    if (auto It = AllocationSites.find(Source); It != AllocationSites.end())
      return It->second.AllocForm;
    return std::nullopt;
  }

  /// Allocation site iterator.
  using const_virtual_iter =
      llvm::DenseMap<const Expr *, AllocationSite>::const_iterator;
  llvm::iterator_range<const_virtual_iter> allocation_sites() const {
    return llvm::make_range(AllocationSites.begin(), AllocationSites.end());
  }

  bool hasAllocations() const { return !AllocationSites.empty(); }

private:
  llvm::DenseMap<const Expr *, AllocationSite> AllocationSites;
  // Allocations that have already been deallocated but had pointers
  // to them.
  llvm::SmallVector<Allocation> DeadAllocations;

  using PoolAllocTy = llvm::BumpPtrAllocator;
  PoolAllocTy DescAllocator;

  /// Allocates a new descriptor.
  template <typename... Ts> Descriptor *allocateDescriptor(Ts &&...Args) {
    return new (DescAllocator) Descriptor(std::forward<Ts>(Args)...);
  }
};

} // namespace interp
} // namespace clang
#endif