/*      $NetBSD: db_trace.c,v 1.26 2019/05/09 16:48:31 ryo Exp $        */

/*-
 * Copyright (c) 2000 Tsubai Masanari.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: db_trace.c,v 1.26 2019/05/09 16:48:31 ryo Exp $");

#include <sys/param.h>
#include <sys/systm.h>

#include <machine/db_machdep.h>

#include <ddb/db_access.h>
#include <ddb/db_interface.h>
#include <ddb/db_output.h>
#include <ddb/db_proc.h>
#include <ddb/db_sym.h>
#include <ddb/db_variables.h>

volatile int db_trace_debug = 0; /* settabble from ddb */
#define DPRINTF(level, fmt, args...)                                    \
        do {                                                            \
                if (__predict_false(db_trace_debug > (level))) {        \
                        print(fmt, ## args);                            \
                }                                                       \
        } while (0 /* CONSTCOND*/)

extern char start[], etext[];
static bool db_nextframe(db_addr_t, db_addr_t, db_addr_t *, db_addr_t *,
    db_addr_t *, void (*)(const char *, ...) __printflike(1, 2));

const struct db_variable db_regs[] = {
        { "r0",   (long *)&ddb_regs.tf_r0,   FCN_NULL },
        { "r1",   (long *)&ddb_regs.tf_r1,   FCN_NULL },
        { "r2",   (long *)&ddb_regs.tf_r2,   FCN_NULL },
        { "r3",   (long *)&ddb_regs.tf_r3,   FCN_NULL },
        { "r4",   (long *)&ddb_regs.tf_r4,   FCN_NULL },
        { "r5",   (long *)&ddb_regs.tf_r5,   FCN_NULL },
        { "r6",   (long *)&ddb_regs.tf_r6,   FCN_NULL },
        { "r7",   (long *)&ddb_regs.tf_r7,   FCN_NULL },
        { "r8",   (long *)&ddb_regs.tf_r8,   FCN_NULL },
        { "r9",   (long *)&ddb_regs.tf_r9,   FCN_NULL },
        { "r10",  (long *)&ddb_regs.tf_r10,  FCN_NULL },
        { "r11",  (long *)&ddb_regs.tf_r11,  FCN_NULL },
        { "r12",  (long *)&ddb_regs.tf_r12,  FCN_NULL },
        { "r13",  (long *)&ddb_regs.tf_r13,  FCN_NULL },
        { "r14",  (long *)&ddb_regs.tf_r14,  FCN_NULL },
        { "r15",  (long *)&ddb_regs.tf_r15,  FCN_NULL },
        { "pr",   (long *)&ddb_regs.tf_pr,   FCN_NULL },
        { "pc",   (long *)&ddb_regs.tf_spc,  FCN_NULL },
        { "sr",   (long *)&ddb_regs.tf_ssr,  FCN_NULL },
        { "mach", (long *)&ddb_regs.tf_mach, FCN_NULL },
        { "macl", (long *)&ddb_regs.tf_macl, FCN_NULL },
};

const struct db_variable * const db_eregs = db_regs + __arraycount(db_regs);

static void
dump_trapframe(struct trapframe *tf,
        void (*print)(const char *, ...) __printflike(1, 2))
{
        print("   sr=%08x   gbr=%08x    pc=%08x     pr=%08x\n",
            tf->tf_ssr, tf->tf_gbr, tf->tf_spc, tf->tf_pr);
        print("   r0=%08x    r1=%08x    r2=%08x     r3=%08x\n",
            tf->tf_r0, tf->tf_r1, tf->tf_r2, tf->tf_r3);
        print("   r4=%08x    r6=%08x    r7=%08x     r8=%08x\n",
            tf->tf_r4, tf->tf_r5, tf->tf_r6, tf->tf_r7);
        print("   r5=%08x    r9=%08x   r10=%08x    r11=%08x\n",
            tf->tf_r8, tf->tf_r9, tf->tf_r10, tf->tf_r11);
        print("  r12=%08x   r13=%08x   r14=%08x sp=r15=%08x\n",
            tf->tf_r12, tf->tf_r13, tf->tf_r14, tf->tf_r15);
}

void
db_stack_trace_print(db_expr_t addr, bool have_addr, db_expr_t count,
        const char *modif, void (*print)(const char *, ...) __printflike(1, 2))
{
        struct trapframe *tf;
        db_addr_t func, pc, lastpc, pr, sp, fp;
        uint32_t vbr;
        bool lwpid = false;
        bool lwpaddr = false;
        const char *cp;
        char c;

        __asm volatile("stc vbr, %0" : "=r"(vbr));

        cp = modif;
        while ((c = *cp++) != 0) {
                if (c == 'a')
                        lwpaddr = true;
                else if (c == 't')
                        lwpid = true;
        }

        if (lwpaddr && lwpid) {
                db_printf("only one of /a or /t can be specified\n");
                return;
        }
        if ((lwpaddr || lwpid) && !have_addr) {
                db_printf("%s required\n", lwpaddr ? "address" : "pid");
                return;
        }

        if (!have_addr) {
                tf = &ddb_regs;
                fp = tf->tf_r14;
                sp = tf->tf_r15;
                pr = tf->tf_pr;
                pc = tf->tf_spc;
                if (pc == 0) {
                        print("calling through null pointer?\n");
                        pc = tf->tf_pr;
                }
                DPRINTF(1, "# trapframe: pc=%lx pr=%lx fp=%lx sp=%lx\n",
                    pc, pr, fp, sp);

        } else if (lwpaddr || lwpid) {
                struct proc *p;
                struct lwp *l;
                struct pcb *pcb;

                if (lwpaddr) {
                        l = (struct lwp *)addr;
                        p = l->l_proc;
                        print("trace: lwp addr %p pid %d ",
                            (void *)addr, p->p_pid);
                } else {
                        pid_t pid = (pid_t)addr;
                        print("trace: pid %d ", pid);
                        p = db_proc_find(pid);
                        if (p == NULL) {
                                print("not found\n");
                                return;
                        }
                        l = LIST_FIRST(&p->p_lwps);
                }
                KASSERT(l != NULL);
                print("lid %d", l->l_lid);
                pcb = lwp_getpcb(l);
                tf = (struct trapframe *)pcb->pcb_sf.sf_r6_bank;
                fp = pcb->pcb_sf.sf_r14;
                sp = pcb->pcb_sf.sf_r15;
                pr = pcb->pcb_sf.sf_pr;
                pc = pcb->pcb_sf.sf_pr;
                print(", fp=%lx, sp=%lx\n", fp, sp);
                DPRINTF(1, "# lwp: pc=%lx pr=%lx fp=%lx sp=%lx\n",
                    pc, pr, fp, sp);
        } else {
                fp = 0;
                sp = addr;
                pr = 0;
                /*
                 * Assume that the frame address (__builtin_frame_address)
                 * passed as an argument is the same level
                 * as this __builtin_return_address().
                 */
                pc = (db_addr_t)__builtin_return_address(0);
        }

        lastpc = 0;
        while (count > 0 && pc != 0 && sp != 0) {
                DPRINTF(2, "# trace: pc=%lx sp=%lx fp=%lx\n", pc, sp, fp);

                /* Are we crossing a trap frame? */
                if ((pc & ~PAGE_MASK) == vbr) {
                        struct trapframe trapframe;
                        tf = &trapframe;

                        /* r14 in exception vectors points to trap frame */
                        db_read_bytes((db_addr_t)fp, sizeof(*tf), (char *)tf);
                        pc = tf->tf_spc;
                        pr = tf->tf_pr;
                        fp = tf->tf_r14;
                        sp = tf->tf_r15;

                        print("<EXPEVT %03x; SSR=%08x> at ",
                            tf->tf_expevt, tf->tf_ssr);
                        db_printsym(pc, DB_STGY_PROC, print);
                        print("\n");

                        print("[trapframe 0x%lx]\n", fp);
                        dump_trapframe(tf, print);

                        /* XXX: don't venture into the userland yet */
                        if ((tf->tf_ssr & PSL_MD) == 0)
                                break;
                } else {
                        const char *name;
                        db_expr_t offset;
                        db_sym_t sym;
                        bool found;

                        sym = db_search_symbol(pc, DB_STGY_ANY, &offset);
                        if (sym == 0) {
                                print("symbol not found\n");
                                break;
                        }
                        db_symbol_values(sym, &name, NULL);

                        func = pc - offset;

                        DPRINTF(1,
                            "    (1) func=%lx+%lx, pc=%lx, sp=%lx, fp=%lx\n",
                            func, offset, pc, sp, fp);

                        found = db_nextframe(func, pc, &fp, &pr, &sp, print);
                        if (!found && lastpc == pc)
                                break;
                        lastpc = pc;

                        DPRINTF(1, "    (2) newpc=%lx, newsp=%lx, newfp=%lx\n",
                            pr, sp, fp);

                        DPRINTF(1, "sp=%lx ", sp);
                        print("%s() at ", name ? name : "");
                        db_printsym(pr, DB_STGY_PROC, print);
                        print("\n");

                        pc = pr;
                        pr = 0;
                }

                count--;
        }
}

static bool
db_nextframe(
        db_addr_t func,         /* in: entry address of current function */
        db_addr_t curpc,        /* in: current pc in the function */
        db_addr_t *fp,          /* out: parent fp */
        db_addr_t *pr,          /* out: parent pr */
        db_addr_t *sp,          /* in: current sp, out: parent sp */
        void (*print)(const char *, ...) __printflike(1, 2))
{
        int *stack = (void *)*sp;
        int i, inst, inst2;
        int depth, prdepth, fpdepth;
        db_addr_t pc;

        if (__predict_false(db_trace_debug >= 2)) {
                DPRINTF(2, "%s:%d: START: func=%lx=", __func__, __LINE__, func);
                db_printsym(func, DB_STGY_PROC, print);
                DPRINTF(2, " pc=%lx fp=%lx pr=%lx, sp=%lx\n",
                    curpc, *fp, *pr, *sp);
        }

        pc = func;
        depth = 0;
        prdepth = fpdepth = -1;

        if (pc < (db_addr_t)start || pc > (db_addr_t)etext)
                goto out;

        for (i = 0; i < 30 && pc < curpc; i++) {
                inst = db_get_value(pc, 2, false);
                DPRINTF(2, "%s:%d: %lx insn=%04x depth=%d\n",
                    __func__, __LINE__, pc, inst, depth);
                pc += 2;

                if (inst == 0x000b)     /* rts - asm routines w/out frame */
                        break;

                if (inst == 0x6ef3)     /* mov r15,r14 -- end of prologue */
                        break;

                if (inst == 0x4f22) {                   /* sts.l pr,@-r15 */
                        prdepth = depth;
                        depth++;
                        continue;
                }
                if (inst == 0x2fe6) {                   /* mov.l r14,@-r15 */
                        fpdepth = depth;
                        depth++;
                        continue;
                }
                if ((inst & 0xff0f) == 0x2f06) {        /* mov.l r?,@-r15 */
                        depth++;
                        continue;
                }
                if ((inst & 0xff00) == 0x7f00) {        /* add #n,r15 */
                        int8_t n = inst & 0xff;

                        if (n >= 0) {
                                /* XXX: in epilogue? ignore it */
                                DPRINTF(2,
                                    "%s:%d: %lx: add #%d,r15 (n > 0) ignored\n",
                                    __func__, __LINE__, pc - 2, n);
                                break;
                        }

                        depth += -n / 4;
                        continue;
                }
                if ((inst & 0xf000) == 0x9000) {
                        inst2 = db_get_value(pc, 2, false);
                        if (((inst2 & 0xff0f) == 0x3f08) &&
                            ((inst & 0x0f00) == ((inst2 & 0x00f0) << 4))) {

                                /* mov <disp>,r?; sub r?,r15 */
                                unsigned int disp = (int)(inst & 0xff);
                                vaddr_t addr;
                                int val;

                                addr = pc + (4 - 2) + (disp << 1);
                                db_read_bytes(addr, sizeof(val), (char *)&val);
                                if ((val & 0x00008000) == 0)
                                        val &= 0x0000ffff;
                                else
                                        val |= 0xffff0000;
                                depth += (val / 4);

                                pc += 2;
                                continue;
                        }
                }

                if (__predict_false(db_trace_debug > 1)) {
                        print("    unknown insn at ");
                        db_printsym(pc - 2, DB_STGY_PROC, print);
                        print(":\t");
                        db_disasm(pc - 2, 0);/* XXX: always uses db_printf */
                }
        }

 out:
        DPRINTF(2, "%s:%d: fpdepth=%d prdepth=%d depth=%d sp=%lx->%lx\n",
            __func__, __LINE__, fpdepth, prdepth, depth, *sp, *sp - depth * 4);

        /* dump stack */
        if (__predict_false(db_trace_debug > 2) &&
            ((fpdepth != -1) || (prdepth != -1))) {
                print("%s:%d: func=%lx pc=%lx\n",
                    __func__, __LINE__, func, curpc);

                for (int j = 0; j < prdepth + 32; j++) {
                        uint32_t v;

                        db_read_bytes((db_addr_t)&stack[j],
                            sizeof(v), (char *)&v);
                        print("  STACK[%2d]: %p: %08x  ",
                            j, &stack[j], v);
                        db_printsym(v, DB_STGY_PROC, print);
                        if (j == (depth - prdepth - 1))
                                print("  # = pr");
                        if (j == (depth - fpdepth - 1))
                                print("  # = fp");
                        print("\n");
                }
        }

        /* fetch fp and pr if exists in stack */
        if (fpdepth != -1)
                db_read_bytes((db_addr_t)&stack[depth - fpdepth - 1],
                    sizeof(*fp), (char *)fp);
        if (prdepth != -1)
                db_read_bytes((db_addr_t)&stack[depth - prdepth - 1],
                    sizeof(*pr), (char *)pr);

        /* adjust stack pointer, and update */
        stack += depth;
        *sp = (db_addr_t)stack;

        if (__predict_false(db_trace_debug >= 2)) {
                DPRINTF(2, "%s:%d: RESULT: fp=%lx pr=%lx(",
                    __func__, __LINE__, *fp, *pr);
                db_printsym(*pr, DB_STGY_PROC, print);
                DPRINTF(2, ") sp=%lx\n", *sp);
        }

        if ((prdepth == -1) && (fpdepth == -1) && (depth == 0))
                return false;
        return true;
}