/*
 * The x86-64 Linux incarnation of arch-dependent OS-dependent
 * routines.  See also "linux-os.c".
 */

/*
 * This software is part of the SBCL system. See the README file for
 * more information.
 *
 * This software is derived from the CMU CL system, which was
 * written at Carnegie Mellon University and released into the
 * public domain. The software is in the public domain and is
 * provided with absolutely no warranty. See the COPYING and CREDITS
 * files for more information.
 */

#define _GNU_SOURCE /* for REG_RAX etc. from sys/ucontext */

#include <stdio.h>
#include <stddef.h>
#include <sys/param.h>
#include <sys/file.h>
#include <sys/types.h>
#include <unistd.h>
#include <errno.h>

#include <sys/ucontext.h>

#include "os.h"
#include "arch.h"
#include "globals.h"
#include "interrupt.h"
#include "interr.h"
#include "lispregs.h"
#include "genesis/sbcl.h"

#include <sys/types.h>
#include <signal.h>
#include <sys/time.h>
#include <sys/stat.h>
#include <unistd.h>
#include <linux/unistd.h>
#include <sys/mman.h>
#include <linux/version.h>
#include "thread.h"             /* dynamic_values_bytes */

#include "validate.h"

int arch_os_thread_init(struct thread *thread) {
#ifdef MEMORY_SANITIZER
    extern __thread unsigned long __msan_param_tls[];
    thread->msan_param_tls = (uword_t)&__msan_param_tls[0];
#endif
    stack_t sigstack;
#ifdef ADDRESS_SANITIZER // maybe skip setting up our own altstack
    /* Asan seems to think it should call munmap() on the alternate signal stack because
     * it believes that it - and only it - called sigaltstack to begin with, due to:
     *   COMMON_FLAG(bool, use_sigaltstack, true,
     *               "If set, uses alternate stack for signal handling.")
     * in llvm-project/compiler-rt/lib/sanitizer_common/sanitizer_flags.inc
     * and
     *   if (common_flags()->use_sigaltstack) SetAlternateSignalStack();
     * which picks a kernel-assigned address. This ocurs before we get here.
     *
     * I suppose when running SBCL, you're supposed to pass a sanitizer flag,
     * but how would users know? Our choices are either to avoid using our own altstack,
     * or undo our altstack and put it back to the ASan-specified stack just before the
     * thread is joined. The consequence of doing otherwise is to see the sanitizer
     * trip over its own shoelaces after we've freed a thread struct, then it queries
     * the OS for the altstack and frees that, which is a double-free, leading to:
#0  __sanitizer::ReportMunmapFailureAndDie () at third_party/llvm/llvm-project/compiler-rt/lib/sanitizer_common/sanitizer_common.cpp:67
#1  0x0000000000364b3d in __sanitizer::UnmapOrDie () at third_party/llvm/llvm-project/compiler-rt/lib/sanitizer_common/sanitizer_posix.cpp:62
#2  0x00000000003662df in __sanitizer::UnsetAlternateSignalStack () at third_party/llvm/llvm-project/compiler-rt/lib/sanitizer_common/sanitizer_posix_libcdep.cpp:210
#3  0x000000000034aceb in __asan::AsanThread::Destroy () at third_party/llvm/llvm-project/compiler-rt/lib/asan/asan_thread.cpp:135
#4  0x00007f33072f0271 in __GI___nptl_deallocate_tsd () at ./nptl/nptl_deallocate_tsd.c:73
#5  __GI___nptl_deallocate_tsd () at ./nptl/nptl_deallocate_tsd.c:22
#6  0x00007f33072f2a4e in start_thread (arg=<optimized out>) at ./nptl/pthread_create.c:456
#7  0x00007f33073707b8 in __GI___clone3 () at ../sysdeps/unix/sysv/linux/x86_64/clone3.S:78
     *
     * In trying to track this down, I did first attempt to completely disable signal stacks,
     * and then due to another bug I caused (in trying to use FORMAT after streams were closed)
     * I got a stack overflow, and the sanitizer didn't help.*/
    memset(&sigstack, 0, sizeof sigstack);
    int res = sigaltstack(0, &sigstack);
    if (res == 0 && sigstack.ss_sp) return 1;
#endif
    // why is this guard even here? It's always C_STACK_IS_CONTROL_STACK for x86-64
#ifdef LISP_FEATURE_C_STACK_IS_CONTROL_STACK
    /* Signal handlers are run on the control stack, so if it is exhausted
     * we had better use an alternate stack for whatever signal tells us
     * we've exhausted it */
    sigstack.ss_sp    = calc_altstack_base(thread);
    sigstack.ss_flags = 0;
    sigstack.ss_size  = calc_altstack_size(thread);
    if(sigaltstack(&sigstack,0)<0) {
        lose("Cannot sigaltstack: %s",strerror(errno));
    }
#endif
    return 1;
}

/* free any arch/os-specific resources used by thread, which is now
 * defunct.  Not called on live threads
 */

int arch_os_thread_cleanup(struct thread __attribute__((unused)) *thread) {
    return 1;
}

/* Visit all registers even if lisp doesn't store pointers there, C
code might be using any register for lisp pointers. */
void visit_context_registers(void (*p)(os_context_register_t,void*),
                             os_context_t *context, void* arg)
{
    mcontext_t* m = &context->uc_mcontext;
    p(m->gregs[REG_RIP], arg);
    // This is the order the registers appear in gregset_t (which makes no difference of course).
    // Not sure why the order is so kooky.
    p(m->gregs[REG_R8 ], arg); p(m->gregs[REG_R9 ], arg); p(m->gregs[REG_R10], arg);
    p(m->gregs[REG_R11], arg); p(m->gregs[REG_R12], arg); p(m->gregs[REG_R13], arg);
    p(m->gregs[REG_R14], arg); p(m->gregs[REG_R15], arg);
    p(m->gregs[REG_RDI], arg); p(m->gregs[REG_RSI], arg); p(m->gregs[REG_RBX], arg);
    p(m->gregs[REG_RDX], arg); p(m->gregs[REG_RAX], arg); p(m->gregs[REG_RCX], arg);
    // We could implicitly pin objects pointed to by parts of an XMM or YMM register here
}

// This array is indexed by the encoding of the register in an instruction.
static unsigned char regmap[16] = {
    REG_RAX, REG_RCX, REG_RDX, REG_RBX, REG_RSP, REG_RBP, REG_RSI, REG_RDI,
    REG_R8,  REG_R9,  REG_R10, REG_R11, REG_R12, REG_R13, REG_R14, REG_R15
};
// So is this one, to coincide with the one above
static char *gprnames[] = {
    "rax","rcx","rdx","rbx","rsp","rbp","rsi","rdi",
    "r8","r9","r10","r11","r12","r13","r14","r15"
};
static char *fprnames[] = {
    "xmm0","xmm1","xmm2","xmm3","xmm4","xmm5","xmm6","xmm7",
    "xmm8","xmm9","xmm10","xmm11","xmm12","xmm13","xmm14","xmm15"
};
static char *flagbits[] = {"CF",0,"PF",0,"AF",0,"ZF","SF","TF","IF","DF","OF"};

void sb_dump_mcontext(char *reason, ucontext_t* context)
{
    /* In case multiple threads receive SIGILL at the same time,
     * we want to try to avoid interleaving their output.
     * Using a single write() call usually does the trick */
    char obuf[2048], smallbuf[100];
    int bit, ptr = 0, i, j;
    smallbuf[0] = smallbuf[1] = 0;
    long unsigned int flags = context->uc_mcontext.gregs[REG_EFL];
    for (bit=11; bit>=0; --bit)
        if (flagbits[bit] && (flags & (1<<bit)))
          ptr += sprintf(smallbuf+ptr, " %s", flagbits[bit]);
#define REMAINING sizeof obuf - ptr
    ptr = 0;
    ptr = snprintf(obuf, REMAINING,
                   THREAD_ID_LABEL" CPU state (%s): PC=%lx Flags={%s}\n",
                   THREAD_ID_VALUE, reason,
                   (uword_t)context->uc_mcontext.gregs[REG_RIP],
                   smallbuf+1);
    // GPRs
    for(i=0; i<2; ++i) {
        for(j=0; j<8; ++j) ptr += snprintf(obuf+ptr, REMAINING, " %16s", gprnames[i*8+j]);
        if (REMAINING) obuf[ptr++] = '\n';
        for(j=0; j<8; ++j)
            ptr += snprintf(obuf+ptr, REMAINING, " %16lX",
                            (uword_t)context->uc_mcontext.gregs[regmap[i*8+j]]);
        if (REMAINING) obuf[ptr++] = '\n';
    }
    // FPRs
    for(i=0; i<4; ++i) {
        for(j=0; j<4; ++j) ptr += snprintf(obuf+ptr, REMAINING, "  %32s", fprnames[i*4+j]);
        if (REMAINING) obuf[ptr++] = '\n';
        for(j=0; j<4; ++j) {
            uint32_t* e = context->uc_mcontext.fpregs->_xmm[i*4+j].element;
            ptr += snprintf(obuf+ptr, REMAINING, "  %08X%08X%08X%08X", e[3], e[2], e[1], e[0]);
        }
        if (REMAINING) obuf[ptr++] = '\n';
    }
    sigset_tostring(&context->uc_sigmask, smallbuf, sizeof smallbuf);
    ptr += snprintf(obuf+ptr, REMAINING, "sigmask=%s\n", smallbuf);
    ignore_value(write(2, obuf, ptr));
}

os_context_register_t *
os_context_register_addr(os_context_t *context, int offset)
{
    if (offset >= 0 && offset < 16)
        return (os_context_register_t*)&context->uc_mcontext.gregs[regmap[offset]];
    return 0;
}

os_context_register_t *
os_context_sp_addr(os_context_t *context)
{
    return (os_context_register_t*)&context->uc_mcontext.gregs[REG_RSP];
}

os_context_register_t *
os_context_fp_addr(os_context_t *context)
{
    return (os_context_register_t*)&context->uc_mcontext.gregs[REG_RBP];
}

unsigned int
os_context_fp_control(os_context_t *context)
{
    return context->uc_mcontext.fpregs->mxcsr ^ (0x3F << 7);
}

void
os_context_set_fp_control(os_context_t *context, unsigned int value)
{
    context->uc_mcontext.fpregs->mxcsr = value ^ (0x3F << 7);
}

os_context_register_t *
os_context_float_register_addr(os_context_t *context, int offset)
{
    return (os_context_register_t*)&context->uc_mcontext.fpregs->_xmm[offset];
}

os_context_register_t *
os_context_ymm_register_addr(os_context_t *context, int offset)
{
#ifdef __USE_GNU
    struct _xstate *xstate = (void*)context->uc_mcontext.fpregs;
    return (os_context_register_t*)&(xstate->ymmh.ymmh_space[offset * 4]);
#else
    void *xstate = (void*)context->uc_mcontext.fpregs;
    return (os_context_register_t*)&((char*)xstate+0x240)[offset * 16];
#endif
}

#define _YMM   2
#define _KMM   5
#define _ZMM   6
#define _ZMMHI 7

/**
 * Resolves the byte offset of an extended xstate.
 */
static int32_t _xfeature_offset(uint64_t xcomp_bv, int xfeature) {
    // If bit 63 is 0, the kernel is running in legacy UNCOMPACTED mode
    if ((xcomp_bv & (1ull << 63)) == 0) {
        switch (xfeature) {
            case _YMM:   return 576;
            case _KMM:   return 1088;
            case _ZMM:   return 1152;
            case _ZMMHI: return 2112;
            default:     return -1;
        }
    }

    // Compacted mode boundary validation
    if ((xcomp_bv & (1ull << xfeature)) == 0)
        return -2; // not currently allocated or tracked

    // Packed streams start immediately after the 64-byte XSAVE header
    int32_t offset = 512 + 64;

    for (int i = 2; i < xfeature; i++) {
        if (xcomp_bv & (1ull << i)) {

            if (i == _ZMM || i == _ZMMHI)
              offset = ALIGN_UP(offset, 64);

            switch (i) {
                case _YMM:   offset += 256;  break; // 16 bytes * 16 registers
                case _KMM:   offset += 64;   break; //  8 bytes * 8  registers
                case _ZMM:   offset += 512;  break; // 32 bytes * 16 registers
                case _ZMMHI: offset += 1024; break; // 64 bytes * 16 registers
                default: break;
            }
        }
    }

    if (xfeature == _ZMM || xfeature == _ZMMHI)
      offset = ALIGN_UP(offset, 64);

    return offset;
}

uint32_t *
os_context_zmm_register_addr(os_context_t *context, int reg)
{
    if (!context || !context->uc_mcontext.fpregs)
        return NULL;

    uint8_t *xstate_base = (uint8_t *)context->uc_mcontext.fpregs;

     /* Read the tracking vector from the XSAVE header (offset 520) */
    uint64_t xcomp_bv = *(uint64_t *)(xstate_base + 512 + 8);

     /* pointer to the upper 256 bits (Bits 256-511) */
    if (reg >= 0 && reg < 16) {
        int32_t offset = _xfeature_offset(xcomp_bv, _ZMM);
        if (offset < 0) return NULL;
        return (uint32_t *)(xstate_base + offset + (reg * 32));
    }

     /* ZMM16 to ZMM31 - 512-bit linear layout (Bits 0-511) */
    else if (reg > 15 && reg < 32) {
        int32_t offset = _xfeature_offset(xcomp_bv, _ZMMHI);
        if (offset < 0) return NULL;
        return (uint32_t *)(xstate_base + offset + ((reg - 16) * 64));
    }

    return NULL;
}

sigset_t *
os_context_sigmask_addr(os_context_t *context)
{
    return &context->uc_sigmask;
}

void NO_SANITIZE_ADDRESS
os_restore_fp_control(os_context_t *context)
{
    if (context->uc_mcontext.fpregs) {
        /* reset exception flags and restore control flags on SSE2 FPU */
        unsigned int temp = (context->uc_mcontext.fpregs->mxcsr) & ~0x3F;
        asm ("ldmxcsr %0" : : "m" (temp));
        /* same for x87 FPU. */
        asm ("fldcw %0" : : "m" (context->uc_mcontext.fpregs->cwd));
    }
}

void
os_flush_icache(os_vm_address_t __attribute__((unused)) address,
                os_vm_size_t __attribute__((unused)) length)
{
}

// To avoid "Missing required foreign symbol" errors in os_link_runtime()
// the executable must actually depend on libm. It would not require libm,
// despite -lm in the link step, if there is no reference to a libm symbol
// observable to the linker. Any one symbol suffices to resolve all of them.
#include <math.h>
const long libm_anchor = (long)acos;

#if defined LISP_FEATURE_SW_INT_AVOIDANCE || defined LISP_FEATURE_PARTIAL_SW_INT_AVOIDANCE
extern void sigtrap_handler();
extern char* vm_thread_name(struct thread*);
extern void sigset_tostring(const sigset_t*, char*, int);
void synchronous_trap(char* savearea, lispobj* sp_at_interrupt)
{
    os_context_t context;
    memset(&context, 0, sizeof context);

    // Create the signal context from the values pushed on the stack
    // by the lisp assembly routine.

#ifndef LISP_FEATURE_PARTIAL_SW_INT_AVOIDANCE
    // I don't know how to create the ucontext's representation from an XSAVE area
    context.uc_mcontext.fpregs = &context.__fpregs_mem;
    if (sizeof context.uc_mcontext.fpregs->_xmm[0].element != 16) lose("sigcontext size bug");
    memcpy(context.uc_mcontext.fpregs->_xmm[0].element, savearea, 16*16);
#endif
    char* gprsave = savearea + 16*32; // 16 32-byte registers
    memcpy(context.uc_mcontext.gregs, gprsave, 15*8);

    context.uc_mcontext.gregs[REG_RSP] = (greg_t)sp_at_interrupt;
    // Take the return-PC to the user code which is 1 word down from exactly where
    // the stack-pointer was at the simulated INT3, then add 1 because a real INT
    // instructions leaves the PC pointing after it.
    long pc_at_interrupt = sp_at_interrupt[-1];
    context.uc_mcontext.gregs[REG_RIP] = 1 + pc_at_interrupt;
    // The first instruction of the asm routine was to push EFLAGS
    context.uc_mcontext.gregs[REG_EFL] = sp_at_interrupt[-2];
    // The next instruction was to push RBP
    context.uc_mcontext.gregs[REG_RBP] = sp_at_interrupt[-3];

    sigset_t curmask;
    thread_sigmask(SIG_UNBLOCK, 0, &curmask); // to read the mask
# define REAL_SIGSET_SIZE_BYTES ((NSIG/8))
    memcpy(&context.uc_sigmask, &curmask, REAL_SIGSET_SIZE_BYTES);
    thread_sigmask(SIG_BLOCK, &blockable_sigset, 0);
    sigset_t newmask;
    sigorset(&newmask, &blockable_sigset, &curmask);

    /* char newmask_string[100];
    sigset_tostring(&newmask, newmask_string, sizeof newmask_string);
    fprintf(stderr, "[%s]: trap: pc=%lx sp=%p savearea=%p newmask=%s\n",
            vm_thread_name(get_sb_vm_thread()),
            os_context_pc(&context), sp_at_interrupt, savearea,
            newmask_string); */

#ifdef LISP_FEATURE_PARTIAL_SW_INT_AVOIDANCE
    // This is for GC auto-triggers during pseudo-atomic, and nothing but
    interrupt_handle_pending(&context);
#else
    sigtrap_handler(0, 0, &context);

    if (context.uc_mcontext.gregs[REG_RSP] != (greg_t)sp_at_interrupt ||
        context.uc_mcontext.gregs[REG_RBP] != (greg_t)sp_at_interrupt[-3])
        lose("don't know how return to a different frame\n");

    // Handler can alter the return PC which we need to stuff into
    // the return PC location that the assembly routine received.
    uword_t return_pc = context.uc_mcontext.gregs[REG_RIP];
    sp_at_interrupt[-1] = return_pc;
#endif

    // act like a return-from-signal by restoring the signal mask
    // Ideally this would be performed in the asm routine only after restoring
    // registers, but it doesn't matter too much.
    thread_sigmask(SIG_SETMASK, &context.uc_sigmask, 0);
}
int wrapped_pthread_sigmask(int how, const void* new, void* old)
{
     char new_string[80], old_string[80];
     sigset_tostring(new, new_string, sizeof new_string);
     int res = pthread_sigmask(how, new, old);
     sigset_tostring(old, old_string, sizeof old_string);
     fprintf(stderr, "[%s]: pthread_sigmask(%s,%s) -> %s\n",
             vm_thread_name(get_sb_vm_thread()),
             how==SIG_BLOCK?"BLOCK":how==SIG_UNBLOCK?"UNBLOCK":"SETMASK",
             new_string, old_string);
     return res;
}
#endif
