SetJmp.h

Go to the documentation of this file.

#ifndef ARCH_SETJMP_SETJMP_H
#define ARCH_SETJMP_SETJMP_H
 
#include "CothreadPrivate.h"
#include "CothreadImpl.h"
 
#include <array>
#include <cstddef>
#include <mutex>
 
#include <csetjmp>
 
namespace libcommunism::internal {
class SetJmp final: public CothreadImpl {
    friend CothreadImpl *libcommunism::AllocKernelThreadWrapper();
 
    public:
        SetJmp(const Entry &entry, const size_t stackSize = 0);
        SetJmp(const Entry &entry, std::span<uintptr_t> stack);
        SetJmp(std::span<uintptr_t> stack) : CothreadImpl(stack) {}
        ~SetJmp();
 
        void switchTo(CothreadImpl *from) override;
 
    private:
        struct EntryContext {
            SetJmp *impl{nullptr};
 
            Cothread::Entry entry;
            EntryContext(SetJmp *_impl, const Cothread::Entry &_entry) : impl(_impl),
                entry(_entry) {}
        };
 
        static auto JmpBufFor(CothreadImpl *thread) {
            return reinterpret_cast<sigjmp_buf *>(static_cast<SetJmp *>(thread)->stack.data());
        }
 
        static void AllocMainCothread();
        static void InvokeCothreadDidReturnHandler(Cothread *from);
        static void SignalHandlerSetupThunk(int);
 
        void Prepare(SetJmp *thread, const Cothread::Entry &entry);
 
    public:
        static constexpr const size_t kStackAlignment{64};
 
        static constexpr const size_t kMainStackSize{512};
 
        static constexpr const size_t kDefaultStackSize{sizeof(uintptr_t) * 0x10000};
 
    private:
        static thread_local std::array<uintptr_t, kMainStackSize> gMainStack;
 
        static EntryContext *gCurrentlyPreparing;
 
        static std::mutex gSignalLock;
 
    private:
        bool ownsStack{false};
};
}
 
#endif