// SPDX-License-Identifier: GPL-2.0

#include <errno.h>
#include <regex.h>
#include <string.h>
#include <linux/kernel.h>
#include <linux/zalloc.h>

#include "../debug.h"
#include "../perf_regs.h"
#include "../../arch/riscv/include/perf_regs.h"

/*
 * RISC-V SDT argument formats (GCC 'nor' constraint):
 *
 * Register:  REG        e.g. a0, t1, s0, sp
 * Memory:    NUM(REG)   e.g. 8(a0), -20(s0)
 * Constant:  NUM        e.g. 99  (not supported by uprobe, skip)
 *
 * Note: 'zero' (x0) is hardwired to 0 and not in pt_regs; skip it.
 *
 * Uprobe target format:
 *   Register: %REG       e.g. %a0
 *   Memory:   +NUM(%REG) or -NUM(%REG)
 */

/* RISC-V register ABI names: ra, sp, gp, tp, t0-t6, s0-s11, a0-a7 */
#define SDT_OP_REGEX1  "^(ra|sp|gp|tp|t[0-6]|s[0-9]|s1[01]|a[0-7])$"

/* RISC-V memory operand: [-]NUM(REG) */
#define SDT_OP_REGEX2  "^(\\-)?([0-9]+)\\((ra|sp|gp|tp|t[0-6]|s[0-9]|s1[01]|a[0-7])\\)$"

static regex_t sdt_op_regex1, sdt_op_regex2;

static int sdt_init_op_regex(void)
{
        static int initialized;
        int ret = 0;

        if (initialized)
                return 0;

        ret = regcomp(&sdt_op_regex1, SDT_OP_REGEX1, REG_EXTENDED);
        if (ret)
                goto error;

        ret = regcomp(&sdt_op_regex2, SDT_OP_REGEX2, REG_EXTENDED);
        if (ret)
                goto free_regex1;

        initialized = 1;
        return 0;

free_regex1:
        regfree(&sdt_op_regex1);
error:
        pr_debug4("Regex compilation error.\n");
        return -ret;
}

/*
 * Parse OP and convert it into uprobe format.
 * Possible variants of OP (RISC-V, GCC 'nor' constraint):
 *
 *   Format         Example       Uprobe
 *   ----------------------------------------
 *   REG            a0            %a0
 *   NUM(REG)       8(a0)         +8(%a0)
 *   -NUM(REG)      -20(s0)       -20(%s0)
 *   NUM            99            (skip, constant not supported)
 */
int __perf_sdt_arg_parse_op_riscv(char *old_op, char **new_op)
{
        int ret, new_len;
        regmatch_t rm[4];
        char prefix;

        /*
         * Constant argument: pure integer with no trailing '(' (e.g. "99", "-1").
         * uprobe does not support immediate values, so skip them.
         * Memory operands like "8(a0)" or "-20(s0)" contain '(' so are NOT
         * treated as constants here; they will be matched by REGEX2 below.
         */
        if (strchr(old_op, '(') == NULL &&
            ((*old_op >= '0' && *old_op <= '9') ||
             (*old_op == '-' && old_op[1] >= '0' && old_op[1] <= '9'))) {
                pr_debug4("Skipping unsupported SDT argument: %s\n", old_op);
                return SDT_ARG_SKIP;
        }

        ret = sdt_init_op_regex();
        if (ret < 0)
                return ret;

        if (!regexec(&sdt_op_regex1, old_op, 2, rm, 0)) {
                /* REG --> %REG */
                new_len = 2;    /* % NULL */
                new_len += (int)(rm[1].rm_eo - rm[1].rm_so);

                *new_op = zalloc(new_len);
                if (!*new_op)
                        return -ENOMEM;

                scnprintf(*new_op, new_len, "%%%.*s",
                        (int)(rm[1].rm_eo - rm[1].rm_so), old_op + rm[1].rm_so);
        } else if (!regexec(&sdt_op_regex2, old_op, 4, rm, 0)) {
                /*
                 * NUM(REG) or -NUM(REG) --> +NUM(%REG) or -NUM(%REG)
                 * rm[1]: optional '-'
                 * rm[2]: decimal offset
                 * rm[3]: register name
                 */
                prefix = (rm[1].rm_so == -1) ? '+' : '-';

                new_len = 5;    /* sign ( % ) NULL */
                new_len += (int)(rm[2].rm_eo - rm[2].rm_so);
                new_len += (int)(rm[3].rm_eo - rm[3].rm_so);

                *new_op = zalloc(new_len);
                if (!*new_op)
                        return -ENOMEM;

                scnprintf(*new_op, new_len, "%c%.*s(%%%.*s)", prefix,
                        (int)(rm[2].rm_eo - rm[2].rm_so), old_op + rm[2].rm_so,
                        (int)(rm[3].rm_eo - rm[3].rm_so), old_op + rm[3].rm_so);
        } else {
                pr_debug4("Skipping unsupported SDT argument: %s\n", old_op);
                return SDT_ARG_SKIP;
        }

        return SDT_ARG_VALID;
}

uint64_t __perf_reg_mask_riscv(bool intr __maybe_unused)
{
        return PERF_REGS_MASK;
}

const char *__perf_reg_name_riscv(int id)
{
        switch (id) {
        case PERF_REG_RISCV_PC:
                return "pc";
        case PERF_REG_RISCV_RA:
                return "ra";
        case PERF_REG_RISCV_SP:
                return "sp";
        case PERF_REG_RISCV_GP:
                return "gp";
        case PERF_REG_RISCV_TP:
                return "tp";
        case PERF_REG_RISCV_T0:
                return "t0";
        case PERF_REG_RISCV_T1:
                return "t1";
        case PERF_REG_RISCV_T2:
                return "t2";
        case PERF_REG_RISCV_S0:
                return "s0";
        case PERF_REG_RISCV_S1:
                return "s1";
        case PERF_REG_RISCV_A0:
                return "a0";
        case PERF_REG_RISCV_A1:
                return "a1";
        case PERF_REG_RISCV_A2:
                return "a2";
        case PERF_REG_RISCV_A3:
                return "a3";
        case PERF_REG_RISCV_A4:
                return "a4";
        case PERF_REG_RISCV_A5:
                return "a5";
        case PERF_REG_RISCV_A6:
                return "a6";
        case PERF_REG_RISCV_A7:
                return "a7";
        case PERF_REG_RISCV_S2:
                return "s2";
        case PERF_REG_RISCV_S3:
                return "s3";
        case PERF_REG_RISCV_S4:
                return "s4";
        case PERF_REG_RISCV_S5:
                return "s5";
        case PERF_REG_RISCV_S6:
                return "s6";
        case PERF_REG_RISCV_S7:
                return "s7";
        case PERF_REG_RISCV_S8:
                return "s8";
        case PERF_REG_RISCV_S9:
                return "s9";
        case PERF_REG_RISCV_S10:
                return "s10";
        case PERF_REG_RISCV_S11:
                return "s11";
        case PERF_REG_RISCV_T3:
                return "t3";
        case PERF_REG_RISCV_T4:
                return "t4";
        case PERF_REG_RISCV_T5:
                return "t5";
        case PERF_REG_RISCV_T6:
                return "t6";
        default:
                return NULL;
        }

        return NULL;
}

uint64_t __perf_reg_ip_riscv(void)
{
        return PERF_REG_RISCV_PC;
}

uint64_t __perf_reg_sp_riscv(void)
{
        return PERF_REG_RISCV_SP;
}