112 lines
2.6 KiB
C++
112 lines
2.6 KiB
C++
|
//===--- 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 "Floating.h"
|
||
|
#include "Integral.h"
|
||
|
#include "Pointer.h"
|
||
|
#include <cassert>
|
||
|
#include <cstdlib>
|
||
|
|
||
|
using namespace clang;
|
||
|
using namespace clang::interp;
|
||
|
|
||
|
InterpStack::~InterpStack() {
|
||
|
clear();
|
||
|
}
|
||
|
|
||
|
void InterpStack::clear() {
|
||
|
if (Chunk && Chunk->Next)
|
||
|
std::free(Chunk->Next);
|
||
|
if (Chunk)
|
||
|
std::free(Chunk);
|
||
|
Chunk = nullptr;
|
||
|
StackSize = 0;
|
||
|
#ifndef NDEBUG
|
||
|
ItemTypes.clear();
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
void *InterpStack::grow(size_t Size) {
|
||
|
assert(Size < ChunkSize - sizeof(StackChunk) && "Object too large");
|
||
|
|
||
|
if (!Chunk || sizeof(StackChunk) + Chunk->size() + Size > ChunkSize) {
|
||
|
if (Chunk && Chunk->Next) {
|
||
|
Chunk = Chunk->Next;
|
||
|
} else {
|
||
|
StackChunk *Next = new (std::malloc(ChunkSize)) StackChunk(Chunk);
|
||
|
if (Chunk)
|
||
|
Chunk->Next = Next;
|
||
|
Chunk = Next;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
auto *Object = reinterpret_cast<void *>(Chunk->End);
|
||
|
Chunk->End += Size;
|
||
|
StackSize += Size;
|
||
|
return Object;
|
||
|
}
|
||
|
|
||
|
void *InterpStack::peekData(size_t Size) const {
|
||
|
assert(Chunk && "Stack is empty!");
|
||
|
|
||
|
StackChunk *Ptr = Chunk;
|
||
|
while (Size > Ptr->size()) {
|
||
|
Size -= Ptr->size();
|
||
|
Ptr = Ptr->Prev;
|
||
|
assert(Ptr && "Offset too large");
|
||
|
}
|
||
|
|
||
|
return reinterpret_cast<void *>(Ptr->End - Size);
|
||
|
}
|
||
|
|
||
|
void InterpStack::shrink(size_t Size) {
|
||
|
assert(Chunk && "Chunk is empty!");
|
||
|
|
||
|
while (Size > Chunk->size()) {
|
||
|
Size -= Chunk->size();
|
||
|
if (Chunk->Next) {
|
||
|
std::free(Chunk->Next);
|
||
|
Chunk->Next = nullptr;
|
||
|
}
|
||
|
Chunk->End = Chunk->start();
|
||
|
Chunk = Chunk->Prev;
|
||
|
assert(Chunk && "Offset too large");
|
||
|
}
|
||
|
|
||
|
Chunk->End -= Size;
|
||
|
StackSize -= Size;
|
||
|
}
|
||
|
|
||
|
void InterpStack::dump() const {
|
||
|
#ifndef NDEBUG
|
||
|
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 (auto TyIt = ItemTypes.rbegin(); TyIt != ItemTypes.rend(); ++TyIt) {
|
||
|
Offset += align(primSize(*TyIt));
|
||
|
|
||
|
llvm::errs() << Index << '/' << Offset << ": ";
|
||
|
TYPE_SWITCH(*TyIt, {
|
||
|
const T &V = peek<T>(Offset);
|
||
|
llvm::errs() << V;
|
||
|
});
|
||
|
llvm::errs() << '\n';
|
||
|
|
||
|
++Index;
|
||
|
}
|
||
|
#endif
|
||
|
}
|