// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Copyright (c) 2025, Oracle and/or its affiliates.
 */

#include <objtool/trace.h>

bool trace;
int trace_depth;

/*
 * Macros to trace CFI state attributes changes.
 */

#define TRACE_CFI_ATTR(attr, prev, next, fmt, ...)              \
({                                                              \
        if ((prev)->attr != (next)->attr)                       \
                TRACE("%s=" fmt " ", #attr, __VA_ARGS__);       \
})

#define TRACE_CFI_ATTR_BOOL(attr, prev, next)                   \
        TRACE_CFI_ATTR(attr, prev, next,                        \
                       "%s", (next)->attr ? "true" : "false")

#define TRACE_CFI_ATTR_NUM(attr, prev, next, fmt)               \
        TRACE_CFI_ATTR(attr, prev, next, fmt, (next)->attr)

#define CFI_REG_NAME_MAXLEN   16

/*
 * Return the name of a register. Note that the same static buffer
 * is returned if the name is dynamically generated.
 */
static const char *cfi_reg_name(unsigned int reg)
{
        static char rname_buffer[CFI_REG_NAME_MAXLEN];
        const char *rname;

        switch (reg) {
        case CFI_UNDEFINED:
                return "<undefined>";
        case CFI_CFA:
                return "cfa";
        case CFI_SP_INDIRECT:
                return "(sp)";
        case CFI_BP_INDIRECT:
                return "(bp)";
        }

        if (reg < CFI_NUM_REGS) {
                rname = arch_reg_name[reg];
                if (rname)
                        return rname;
        }

        if (snprintf(rname_buffer, CFI_REG_NAME_MAXLEN, "r%d", reg) == -1)
                return "<error>";

        return (const char *)rname_buffer;
}

/*
 * Functions and macros to trace CFI registers changes.
 */

static void trace_cfi_reg(const char *prefix, int reg, const char *fmt,
                          int base_prev, int offset_prev,
                          int base_next, int offset_next)
{
        char *rname;

        if (base_prev == base_next && offset_prev == offset_next)
                return;

        if (prefix)
                TRACE("%s:", prefix);

        if (base_next == CFI_UNDEFINED) {
                TRACE("%1$s=<undef> ", cfi_reg_name(reg));
        } else {
                rname = strdup(cfi_reg_name(reg));
                TRACE(fmt, rname, cfi_reg_name(base_next), offset_next);
                free(rname);
        }
}

static void trace_cfi_reg_val(const char *prefix, int reg,
                              int base_prev, int offset_prev,
                              int base_next, int offset_next)
{
        trace_cfi_reg(prefix, reg, "%1$s=%2$s%3$+d ",
                      base_prev, offset_prev, base_next, offset_next);
}

static void trace_cfi_reg_ref(const char *prefix, int reg,
                              int base_prev, int offset_prev,
                              int base_next, int offset_next)
{
        trace_cfi_reg(prefix, reg, "%1$s=(%2$s%3$+d) ",
                      base_prev, offset_prev, base_next, offset_next);
}

#define TRACE_CFI_REG_VAL(reg, prev, next)                              \
        trace_cfi_reg_val(NULL, reg, prev.base, prev.offset,            \
                          next.base, next.offset)

#define TRACE_CFI_REG_REF(reg, prev, next)                              \
        trace_cfi_reg_ref(NULL, reg, prev.base, prev.offset,            \
                          next.base, next.offset)

void trace_insn_state(struct instruction *insn, struct insn_state *sprev,
                      struct insn_state *snext)
{
        struct cfi_state *cprev, *cnext;
        int i;

        if (!memcmp(sprev, snext, sizeof(struct insn_state)))
                return;

        cprev = &sprev->cfi;
        cnext = &snext->cfi;

        disas_print_insn(stderr, objtool_disas_ctx, insn,
                         trace_depth - 1, "state: ");

        /* print registers changes */
        TRACE_CFI_REG_VAL(CFI_CFA, cprev->cfa, cnext->cfa);
        for (i = 0; i < CFI_NUM_REGS; i++) {
                TRACE_CFI_REG_VAL(i, cprev->vals[i], cnext->vals[i]);
                TRACE_CFI_REG_REF(i, cprev->regs[i], cnext->regs[i]);
        }

        /* print attributes changes */
        TRACE_CFI_ATTR_NUM(stack_size, cprev, cnext, "%d");
        TRACE_CFI_ATTR_BOOL(drap, cprev, cnext);
        if (cnext->drap) {
                trace_cfi_reg_val("drap", cnext->drap_reg,
                                  cprev->drap_reg, cprev->drap_offset,
                                  cnext->drap_reg, cnext->drap_offset);
        }
        TRACE_CFI_ATTR_BOOL(bp_scratch, cprev, cnext);
        TRACE_CFI_ATTR_NUM(instr, sprev, snext, "%d");
        TRACE_CFI_ATTR_NUM(uaccess_stack, sprev, snext, "%u");

        TRACE("\n");

        insn->trace = 1;
}

void trace_alt_begin(struct instruction *orig_insn, struct alternative *alt,
                     char *alt_name)
{
        struct instruction *alt_insn;
        char suffix[2];

        alt_insn = alt->insn;

        if (alt->type == ALT_TYPE_EX_TABLE) {
                /*
                 * When there is an exception table then the instruction
                 * at the original location is executed but it can cause
                 * an exception. In that case, the execution will be
                 * redirected to the alternative instruction.
                 *
                 * The instruction at the original location can have
                 * instruction alternatives, so we just print the location
                 * of the instruction that can cause the exception and
                 * not the instruction itself.
                 */
                TRACE_ALT_INFO_NOADDR(orig_insn, "/ ", "%s for instruction at 0x%lx <%s+0x%lx>",
                                      alt_name,
                                      orig_insn->offset, orig_insn->sym->name,
                                      orig_insn->offset - orig_insn->sym->offset);
        } else {
                TRACE_ALT_INFO_NOADDR(orig_insn, "/ ", "%s", alt_name);
        }

        if (alt->type == ALT_TYPE_JUMP_TABLE) {
                /*
                 * For a jump alternative, if the default instruction is
                 * a NOP then it is replaced with the jmp instruction,
                 * otherwise it is replaced with a NOP instruction.
                 */
                trace_depth++;
                if (orig_insn->type == INSN_NOP) {
                        suffix[0] = (orig_insn->len == 5) ? 'q' : '\0';
                        TRACE_ADDR(orig_insn, "jmp%-3s %lx <%s+0x%lx>", suffix,
                                   alt_insn->offset, alt_insn->sym->name,
                                   alt_insn->offset - alt_insn->sym->offset);
                } else {
                        TRACE_ADDR(orig_insn, "nop%d", orig_insn->len);
                        trace_depth--;
                }
        }
}

void trace_alt_end(struct instruction *orig_insn, struct alternative *alt,
                   char *alt_name)
{
        if (alt->type == ALT_TYPE_JUMP_TABLE && orig_insn->type == INSN_NOP)
                trace_depth--;
        TRACE_ALT_INFO_NOADDR(orig_insn, "\\ ", "%s", alt_name);
}