/src/llvm-project/clang/lib/AST/Interp/InterpStack.h

Source (jump to first uncovered line)
//===--- InterpStack.h - Stack implementation 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
//
//===----------------------------------------------------------------------===//
//
// Defines the upwards-growing stack used by the interpreter.
//
//===----------------------------------------------------------------------===//

#ifndef LLVM_CLANG_AST_INTERP_INTERPSTACK_H
#define LLVM_CLANG_AST_INTERP_INTERPSTACK_H

#include "FunctionPointer.h"
#include "IntegralAP.h"
#include "PrimType.h"
#include <memory>
#include <vector>

namespace clang {
namespace interp {

/// Stack frame storing temporaries and parameters.
class InterpStack final {
public:
  InterpStack() {}

  /// Destroys the stack, freeing up storage.
  ~InterpStack();

  /// Constructs a value in place on the top of the stack.
  template <typename T, typename... Tys> void push(Tys &&... Args) {
    new (grow(aligned_size<T>())) T(std::forward<Tys>(Args)...);
#ifndef NDEBUG
    ItemTypes.push_back(toPrimType<T>());
#endif
  }

  /// Returns the value from the top of the stack and removes it.
  template <typename T> T pop() {
#ifndef NDEBUG
    assert(!ItemTypes.empty());
    assert(ItemTypes.back() == toPrimType<T>());
    ItemTypes.pop_back();
#endif
    T *Ptr = &peekInternal<T>();
    T Value = std::move(*Ptr);
    Ptr->~T();
    shrink(aligned_size<T>());
    return Value;
  }

  /// Discards the top value from the stack.
  template <typename T> void discard() {
#ifndef NDEBUG
    assert(!ItemTypes.empty());
    assert(ItemTypes.back() == toPrimType<T>());
    ItemTypes.pop_back();
#endif
    T *Ptr = &peekInternal<T>();
    Ptr->~T();
    shrink(aligned_size<T>());
  }

  /// Returns a reference to the value on the top of the stack.
  template <typename T> T &peek() const {
#ifndef NDEBUG
    assert(!ItemTypes.empty());
    assert(ItemTypes.back() == toPrimType<T>());
#endif
    return peekInternal<T>();
  }

  template <typename T> T &peek(size_t Offset) const {
    assert(aligned(Offset));
    return *reinterpret_cast<T *>(peekData(Offset));
  }

  /// Returns a pointer to the top object.
  void *top() const { return Chunk ? peekData(0) : nullptr; }

  /// Returns the size of the stack in bytes.
  size_t size() const { return StackSize; }

  /// Clears the stack without calling any destructors.
  void clear();

  /// Returns whether the stack is empty.
  bool empty() const { return StackSize == 0; }

  /// dump the stack contents to stderr.
  void dump() const;

private:
  /// All stack slots are aligned to the native pointer alignment for storage.
  /// The size of an object is rounded up to a pointer alignment multiple.
  template <typename T> constexpr size_t aligned_size() const {
    constexpr size_t PtrAlign = alignof(void *);
    return ((sizeof(T) + PtrAlign - 1) / PtrAlign) * PtrAlign;
  }

  /// Like the public peek(), but without the debug type checks.
  template <typename T> T &peekInternal() const {
    return *reinterpret_cast<T *>(peekData(aligned_size<T>()));
  }

  /// Grows the stack to accommodate a value and returns a pointer to it.
  void *grow(size_t Size);
  /// Returns a pointer from the top of the stack.
  void *peekData(size_t Size) const;
  /// Shrinks the stack.
  void shrink(size_t Size);

  /// Allocate stack space in 1Mb chunks.
  static constexpr size_t ChunkSize = 1024 * 1024;

  /// Metadata for each stack chunk.
  ///
  /// The stack is composed of a linked list of chunks. Whenever an allocation
  /// is out of bounds, a new chunk is linked. When a chunk becomes empty,
  /// it is not immediately freed: a chunk is deallocated only when the
  /// predecessor becomes empty.
  struct StackChunk {
    StackChunk *Next;
    StackChunk *Prev;
    char *End;

    StackChunk(StackChunk *Prev = nullptr)
        : Next(nullptr), Prev(Prev), End(reinterpret_cast<char *>(this + 1)) {}

    /// Returns the size of the chunk, minus the header.
    size_t size() const { return End - start(); }

    /// Returns a pointer to the start of the data region.
    char *start() { return reinterpret_cast<char *>(this + 1); }
    const char *start() const {
      return reinterpret_cast<const char *>(this + 1);
    }
  };
  static_assert(sizeof(StackChunk) < ChunkSize, "Invalid chunk size");

  /// First chunk on the stack.
  StackChunk *Chunk = nullptr;
  /// Total size of the stack.
  size_t StackSize = 0;

#ifndef NDEBUG
  /// vector recording the type of data we pushed into the stack.
  std::vector<PrimType> ItemTypes;

  template <typename T> static constexpr PrimType toPrimType() {
    if constexpr (std::is_same_v<T, Pointer>)
      return PT_Ptr;
    else if constexpr (std::is_same_v<T, bool> ||
                       std::is_same_v<T, Boolean>)
      return PT_Bool;
    else if constexpr (std::is_same_v<T, int8_t> ||
                       std::is_same_v<T, Integral<8, true>>)
      return PT_Sint8;
    else if constexpr (std::is_same_v<T, uint8_t> ||
                       std::is_same_v<T, Integral<8, false>>)
      return PT_Uint8;
    else if constexpr (std::is_same_v<T, int16_t> ||
                       std::is_same_v<T, Integral<16, true>>)
      return PT_Sint16;
    else if constexpr (std::is_same_v<T, uint16_t> ||
                       std::is_same_v<T, Integral<16, false>>)
      return PT_Uint16;
    else if constexpr (std::is_same_v<T, int32_t> ||
                       std::is_same_v<T, Integral<32, true>>)
      return PT_Sint32;
    else if constexpr (std::is_same_v<T, uint32_t> ||
                       std::is_same_v<T, Integral<32, false>>)
      return PT_Uint32;
    else if constexpr (std::is_same_v<T, int64_t> ||
                       std::is_same_v<T, Integral<64, true>>)
      return PT_Sint64;
    else if constexpr (std::is_same_v<T, uint64_t> ||
                       std::is_same_v<T, Integral<64, false>>)
      return PT_Uint64;
    else if constexpr (std::is_same_v<T, Floating>)
      return PT_Float;
    else if constexpr (std::is_same_v<T, FunctionPointer>)
      return PT_FnPtr;
    else if constexpr (std::is_same_v<T, IntegralAP<true>>)
      return PT_IntAP;
    else if constexpr (std::is_same_v<T, IntegralAP<false>>)
      return PT_IntAP;

    llvm_unreachable("unknown type push()'ed into InterpStack");
  }
#endif
};

} // namespace interp
} // namespace clang

#endif

Coverage Report

Created: 2024-01-17 10:31

Line	Count	Source (jump to first uncovered line)
1		//===--- InterpStack.h - Stack implementation for the VM --------- C++ --===//
2		//
3		// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4		// See https://llvm.org/LICENSE.txt for license information.
5		// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6		//
7		//===----------------------------------------------------------------------===//
8		//
9		// Defines the upwards-growing stack used by the interpreter.
10		//
11		//===----------------------------------------------------------------------===//
12
13		#ifndef LLVM_CLANG_AST_INTERP_INTERPSTACK_H
14		#define LLVM_CLANG_AST_INTERP_INTERPSTACK_H
15
16		#include "FunctionPointer.h"
17		#include "IntegralAP.h"
18		#include "PrimType.h"
19		#include <memory>
20		#include <vector>
21
22		namespace clang {
23		namespace interp {
24
25		/// Stack frame storing temporaries and parameters.
26		class InterpStack final {
27		public:
28	0	InterpStack() {}
29
30		/// Destroys the stack, freeing up storage.
31		~InterpStack();
32
33		/// Constructs a value in place on the top of the stack.
34	0	template <typename T, typename... Tys> void push(Tys &&... Args) {
35	0	new (grow(aligned_size<T>())) T(std::forward<Tys>(Args)...);
36	0	#ifndef NDEBUG
37	0	ItemTypes.push_back(toPrimType<T>());
38	0	#endif
39	0	} Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::Floating, clang::interp::Floating&>(clang::interp::Floating&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::Boolean, clang::interp::Boolean>(clang::interp::Boolean&&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::Pointer, clang::interp::Pointer>(clang::interp::Pointer&&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::IntegralAP<true>, clang::interp::IntegralAP<true> >(clang::interp::IntegralAP<true>&&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::IntegralAP<false>, clang::interp::IntegralAP<false> >(clang::interp::IntegralAP<false>&&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::Pointer, clang::interp::Pointer const&>(clang::interp::Pointer const&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::FunctionPointer, clang::interp::Function const&>(clang::interp::Function const&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::Pointer, clang::interp::Block&, unsigned long>(clang::interp::Block&, unsigned long&&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::Integral<8u, true>, clang::interp::Integral<8u, true>&>(clang::interp::Integral<8u, true>&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::Integral<8u, false>, clang::interp::Integral<8u, false>&>(clang::interp::Integral<8u, false>&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::Integral<16u, true>, clang::interp::Integral<16u, true>&>(clang::interp::Integral<16u, true>&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::Integral<16u, false>, clang::interp::Integral<16u, false>&>(clang::interp::Integral<16u, false>&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::Integral<32u, true>, clang::interp::Integral<32u, true>&>(clang::interp::Integral<32u, true>&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::Integral<32u, false>, clang::interp::Integral<32u, false>&>(clang::interp::Integral<32u, false>&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::Integral<64u, true>, clang::interp::Integral<64u, true>&>(clang::interp::Integral<64u, true>&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::Integral<64u, false>, clang::interp::Integral<64u, false>&>(clang::interp::Integral<64u, false>&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::IntegralAP<false>, clang::interp::IntegralAP<false>&>(clang::interp::IntegralAP<false>&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::IntegralAP<true>, clang::interp::IntegralAP<true>&>(clang::interp::IntegralAP<true>&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::Boolean, clang::interp::Boolean&>(clang::interp::Boolean&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::Integral<8u, false>, clang::interp::Integral<8u, false> >(clang::interp::Integral<8u, false>&&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::Integral<8u, true>, clang::interp::Integral<8u, true> >(clang::interp::Integral<8u, true>&&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::Integral<16u, false>, clang::interp::Integral<16u, false> >(clang::interp::Integral<16u, false>&&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::Integral<16u, true>, clang::interp::Integral<16u, true> >(clang::interp::Integral<16u, true>&&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::Integral<32u, false>, clang::interp::Integral<32u, false> >(clang::interp::Integral<32u, false>&&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::Integral<32u, true>, clang::interp::Integral<32u, true> >(clang::interp::Integral<32u, true>&&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::Integral<64u, false>, clang::interp::Integral<64u, false> >(clang::interp::Integral<64u, false>&&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::Integral<64u, true>, clang::interp::Integral<64u, true> >(clang::interp::Integral<64u, true>&&) Unexecuted instantiation: void clang::interp::InterpStack::push<bool, bool const&>(bool const&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::Floating, clang::interp::Floating const&>(clang::interp::Floating const&) Unexecuted instantiation: void clang::interp::InterpStack::push<signed char, signed char const&>(signed char const&) Unexecuted instantiation: void clang::interp::InterpStack::push<short, short const&>(short const&) Unexecuted instantiation: void clang::interp::InterpStack::push<int, int const&>(int const&) Unexecuted instantiation: void clang::interp::InterpStack::push<long, long const&>(long const&) Unexecuted instantiation: void clang::interp::InterpStack::push<unsigned char, unsigned char const&>(unsigned char const&) Unexecuted instantiation: void clang::interp::InterpStack::push<unsigned short, unsigned short const&>(unsigned short const&) Unexecuted instantiation: void clang::interp::InterpStack::push<unsigned int, unsigned int const&>(unsigned int const&) Unexecuted instantiation: void clang::interp::InterpStack::push<unsigned long, unsigned long const&>(unsigned long const&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::Integral<8u, true>, clang::interp::Integral<8u, true> const&>(clang::interp::Integral<8u, true> const&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::Integral<8u, false>, clang::interp::Integral<8u, false> const&>(clang::interp::Integral<8u, false> const&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::Integral<16u, true>, clang::interp::Integral<16u, true> const&>(clang::interp::Integral<16u, true> const&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::Integral<16u, false>, clang::interp::Integral<16u, false> const&>(clang::interp::Integral<16u, false> const&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::Integral<32u, true>, clang::interp::Integral<32u, true> const&>(clang::interp::Integral<32u, true> const&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::Integral<32u, false>, clang::interp::Integral<32u, false> const&>(clang::interp::Integral<32u, false> const&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::Integral<64u, true>, clang::interp::Integral<64u, true> const&>(clang::interp::Integral<64u, true> const&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::Integral<64u, false>, clang::interp::Integral<64u, false> const&>(clang::interp::Integral<64u, false> const&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::IntegralAP<false>, clang::interp::IntegralAP<false> const&>(clang::interp::IntegralAP<false> const&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::IntegralAP<true>, clang::interp::IntegralAP<true> const&>(clang::interp::IntegralAP<true> const&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::Pointer, clang::interp::Pointer&>(clang::interp::Pointer&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::FunctionPointer, clang::interp::FunctionPointer&>(clang::interp::FunctionPointer&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::Boolean, clang::interp::Boolean const&>(clang::interp::Boolean const&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::FunctionPointer, clang::interp::FunctionPointer const&>(clang::interp::FunctionPointer const&) Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::Pointer>() Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::FunctionPointer>() Unexecuted instantiation: void clang::interp::InterpStack::push<clang::interp::Floating, clang::interp::Floating>(clang::interp::Floating&&)