TheRock/compiler/amd-llvm/clang/lib/AST/ByteCode/InterpStack.cpp

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

#include "InterpStack.h"
#include "Boolean.h"
#include "Char.h"
#include "FixedPoint.h"
#include "Floating.h"
#include "Integral.h"
#include "MemberPointer.h"
#include "Pointer.h"
#include <cassert>
#include <cstdlib>

using namespace clang;
using namespace clang::interp;

InterpStack::~InterpStack() {
  if (Chunk && Chunk->Next)
    std::free(Chunk->Next);
  if (Chunk)
    std::free(Chunk);
}

// We keep the last chunk around to reuse.
void InterpStack::clear() {
  for (PrimType Item : llvm::reverse(ItemTypes)) {
    TYPE_SWITCH(Item, { this->discard<T>(); });
  }
  assert(ItemTypes.empty());
  assert(empty());
}

void InterpStack::clearTo(size_t NewSize) {
  if (NewSize == 0)
    return clear();
  if (NewSize == size())
    return;

  assert(NewSize <= size());
  for (PrimType Item : llvm::reverse(ItemTypes)) {
    TYPE_SWITCH(Item, { this->discard<T>(); });

    if (size() == NewSize)
      break;
  }

  // Note: discard() above already removed the types from ItemTypes.
  assert(size() == NewSize);
}

void *InterpStack::peekData(size_t Size) const {
  assert(Chunk && "Stack is empty!");

  if (LLVM_LIKELY(Size <= Chunk->size()))
    return reinterpret_cast<void *>(Chunk->start() + Chunk->Size - Size);

  StackChunk *Ptr = Chunk;
  while (Size > Ptr->size()) {
    Size -= Ptr->size();
    Ptr = Ptr->Prev;
    assert(Ptr && "Offset too large");
  }

  return reinterpret_cast<void *>(Ptr->start() + Ptr->Size - Size);
}

void InterpStack::shrink(size_t Size) {
  assert(Chunk && "Chunk is empty!");

  // Likely case is that we simply remove something from the current chunk.
  if (LLVM_LIKELY(Size <= Chunk->size())) {
    Chunk->Size -= Size;
    StackSize -= Size;
    return;
  }

  while (Size > Chunk->size()) {
    Size -= Chunk->size();
    if (Chunk->Next) {
      std::free(Chunk->Next);
      Chunk->Next = nullptr;
    }
    Chunk->Size = 0;
    Chunk = Chunk->Prev;
    assert(Chunk && "Offset too large");
  }

  Chunk->Size -= Size;
  StackSize -= Size;
}

void InterpStack::dump() const {
  llvm::errs() << "Items: " << ItemTypes.size() << ". Size: " << size() << '\n';
  if (ItemTypes.empty())
    return;

  size_t Index = 0;
  size_t Offset = 0;

  // The type of the item on the top of the stack is inserted to the back
  // of the vector, so the iteration has to happen backwards.
  for (PrimType Item : llvm::reverse(ItemTypes)) {
    Offset += align(primSize(Item));

    llvm::errs() << Index << '/' << Offset << ": ";
    TYPE_SWITCH(Item, {
      const T &V = peek<T>(Offset);
      llvm::errs() << V;
    });
    llvm::errs() << '\n';

    ++Index;
  }
}