Common.cpp

Go to the documentation of this file.

 
#include "Common.h"
#include "CothreadPrivate.h"
 
#include <algorithm>
#include <array>
#include <cstddef>
#include <exception>
#include <functional>
#include <memory>
#include <stdexcept>
#include <thread>
 
using namespace libcommunism;
using namespace libcommunism::internal;
 
thread_local std::array<uintptr_t, Aarch64::kMainStackSize> Aarch64::gMainStack;
 
 
 
Aarch64::Aarch64(const Entry &entry, const size_t stackSize) : CothreadImpl(entry, stackSize) {
    void *buf{nullptr};
 
    // round down stack size to ensure it's aligned before allocating it
    auto allocSize = stackSize & ~(Aarch64::kStackAlignment - 1);
    allocSize = allocSize ? allocSize : Aarch64::kDefaultStackSize;
    allocSize += Aarch64::kContextSaveAreaSize;
 
    buf = Aarch64::AllocStack(allocSize);
 
    // create it as if we had provided the memory in the first place
    this->stack = {reinterpret_cast<uintptr_t *>(buf), allocSize / sizeof(uintptr_t)};
    this->ownsStack = true;
 
    Aarch64::Prepare(this, entry);
}
 
Aarch64::Aarch64(const Entry &entry, std::span<uintptr_t> _stack) : CothreadImpl(entry, _stack) {
    Aarch64::ValidateStackSize(_stack.size() * sizeof(uintptr_t));
    Aarch64::Prepare(this, entry);
}
 
Aarch64::Aarch64(std::span<uintptr_t> stack) : CothreadImpl(stack), stackTop(stack.data()) {
}
 
 
Aarch64::~Aarch64() {
    if(this->ownsStack) {
        DeallocStack(this->stack.data());
    }
}
 
void Aarch64::switchTo(CothreadImpl *from) {
    Switch(static_cast<Aarch64 *>(from), this);
}
 
void Aarch64::ValidateStackSize(const size_t size) {
    if(!size) throw std::runtime_error("Size may not be nil");
    if(size % kStackAlignment) throw std::runtime_error("Stack is misaligned");
}
 
void Aarch64::CothreadReturned() {
    gReturnHandler(Cothread::Current());
}
 
void Aarch64::DereferenceCallInfo(CallInfo *info) {
    info->entry();
    delete info;
 
    CothreadReturned();
    gReturnHandler(Cothread::Current());
 
    // if the return handler returns, we will crash. so abort to make debugging easier
    std::terminate();
}
 
 
 
CothreadImpl *libcommunism::AllocKernelThreadWrapper() {
    return new Aarch64(Aarch64::gMainStack);
}