xml.c

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2017-2018 srimanta.barua1 <srimanta.barua1@gmail.com>
// SPDX-License-Identifier: LGPL-3.0-only
 
#include "gdbclient/xml.h"
#include "gdbclient/commands.h"
#include "gdbclient/core.h"
#include "arch.h"
#include "gdbr_common.h"
#include "packet.h"
#include <rz_util.h>
#include <rz_debug.h>
 
#define MAX_PID_CHARS (5)
 
static char *gdbr_read_feature(libgdbr_t *g, const char *file, ut64 *tot_len) {
    ut64 retlen = 0, retmax = 0, off = 0, len = g->stub_features.pkt_sz - 2,
         blksz = g->data_max, subret_space = 0, subret_len = 0;
    char *tmp, *tmp2, *tmp3, *ret = NULL, *subret = NULL, msg[128] = { 0 },
                 status, tmpchar;
    while (1) {
        snprintf(msg, sizeof(msg), "qXfer:features:read:%s:%" PFMT64x ",%" PFMT64x, file, off, len);
        if (send_msg(g, msg) < 0 || read_packet(g, false) < 0 || send_ack(g) < 0) {
            goto exit_err;
        }
        if (g->data_len == 0) {
            goto exit_err;
        }
        if (g->data_len == 1 && g->data[0] == 'l') {
            break;
        }
        status = g->data[0];
        if (retmax - retlen < g->data_len) {
            if (!(tmp = realloc(ret, retmax + blksz))) {
                goto exit_err;
            }
            retmax += blksz;
            ret = tmp;
        }
        strcpy(ret + retlen, g->data + 1);
        retlen += g->data_len - 1;
        off = retlen;
        if (status == 'l') {
            break;
        }
        if (status != 'm') {
            goto exit_err;
        }
    }
    if (!ret) {
        *tot_len = 0;
        return NULL;
    }
    tmp = strstr(ret, "<xi:include");
    while (tmp) {
        // inclusion
        if (!(tmp2 = strstr(tmp, "/>"))) {
            goto exit_err;
        }
        subret_space = tmp2 + 2 - tmp;
        if (!(tmp2 = strstr(tmp, "href="))) {
            goto exit_err;
        }
        tmp2 += 6;
        if (!(tmp3 = strchr(tmp2, '"'))) {
            goto exit_err;
        }
        tmpchar = *tmp3;
        *tmp3 = '\0';
        subret = gdbr_read_feature(g, tmp2, &subret_len);
        *tmp3 = tmpchar;
        if (subret) {
            if (subret_len <= subret_space) {
                memcpy(tmp, subret, subret_len);
                memcpy(tmp + subret_len, tmp + subret_space,
                    retlen - (tmp + subret_space - ret));
                retlen -= subret_space - subret_len;
                ret[retlen] = '\0';
                tmp = strstr(tmp3, "<xi:include");
                free(subret);
                continue;
            }
            if (subret_len > retmax - retlen - 1) {
                tmp3 = NULL;
                if (!(tmp3 = realloc(ret, retmax + subret_len))) {
                    free(subret);
                    goto exit_err;
                }
                tmp = tmp3 + (tmp - ret);
                ret = tmp3;
                retmax += subret_len + 1;
            }
            memmove(tmp + subret_len, tmp + subret_space,
                retlen - (tmp + subret_space - ret));
            memcpy(tmp, subret, subret_len);
            retlen += subret_len - subret_space;
            ret[retlen] = '\0';
            free(subret);
        }
        tmp = strstr(tmp3, "<xi:include");
    }
    *tot_len = retlen;
    return ret;
exit_err:
    free(ret);
    *tot_len = 0;
    return NULL;
}
 
static char *gdbr_read_osdata(libgdbr_t *g, const char *file, ut64 *tot_len) {
    ut64 retlen = 0, retmax = 0, off = 0, len = g->stub_features.pkt_sz - 2,
         blksz = g->data_max;
    char *tmp, *ret = NULL, msg[128] = { 0 }, status;
    while (1) {
        snprintf(msg, sizeof(msg), "qXfer:osdata:read:%s:%" PFMT64x ",%" PFMT64x, file, off, len);
        if (send_msg(g, msg) < 0 || read_packet(g, false) < 0 || send_ack(g) < 0) {
            goto exit_err;
        }
        if (g->data_len == 0) {
            goto exit_err;
        }
        if (g->data_len == 1 && g->data[0] == 'l') {
            break;
        }
        status = g->data[0];
        if (retmax - retlen < g->data_len) {
            if (!(tmp = realloc(ret, retmax + blksz))) {
                goto exit_err;
            }
            retmax += blksz;
            ret = tmp;
        }
        strcpy(ret + retlen, g->data + 1);
        retlen += g->data_len - 1;
        off = retlen;
        if (status == 'l') {
            break;
        }
    }
    if (!ret) {
        *tot_len = 0;
        return NULL;
    }
    *tot_len = retlen;
    return ret;
exit_err:
    free(ret);
    *tot_len = 0;
    return NULL;
}
 
typedef struct {
    char type[32];
    struct {
        char name[32];
        ut32 bit_num;
        ut32 sz; // size in bits
    } fields[64];
    ut32 num_bits;
    ut32 num_fields;
} gdbr_xml_flags_t;
 
typedef struct {
    char name[32];
    char type[8];
    ut32 size;
    ut32 flagnum;
} gdbr_xml_reg_t;
 
static void _write_flag_bits(char *buf, const gdbr_xml_flags_t *flags);
static int _resolve_arch(libgdbr_t *g, char *xml_data);
static RzList *_extract_flags(char *flagstr);
static RzList *_extract_regs(char *regstr, RzList *flags, char *pc_alias);
static RzDebugPid *_extract_pid_info(const char *info, const char *path, int tid);
 
static int gdbr_parse_target_xml(libgdbr_t *g, char *xml_data, ut64 len) {
    char *regstr, *flagstr, *tmp, *profile = NULL, pc_alias[64], flag_bits[65];
    RzList *flags, *regs;
    RzListIter *iter;
    gdbr_xml_flags_t *tmpflag;
    gdbr_xml_reg_t *tmpreg;
    int packed_size = 0;
    ut64 profile_len = 0, profile_max_len, regnum = 0, regoff = 0;
    pc_alias[0] = '\0';
    gdb_reg_t *arch_regs = NULL;
    if (_resolve_arch(g, xml_data) < 0) {
        return -1;
    }
    if (!(flagstr = strstr(xml_data, "<feature"))) {
        return -1;
    }
    regstr = flagstr;
    if (!(flags = _extract_flags(flagstr))) {
        return -1;
    }
    if (!(regs = _extract_regs(regstr, flags, pc_alias))) {
        rz_list_free(flags);
        return -1;
    }
    if (!(arch_regs = malloc(sizeof(gdb_reg_t) * (rz_list_length(regs) + 1)))) {
        goto exit_err;
    }
    // approximate per-reg size estimates
    profile_max_len = rz_list_length(regs) * 128 + rz_list_length(flags) * 128;
    if (!(profile = malloc(profile_max_len))) {
        goto exit_err;
    }
    rz_list_foreach (regs, iter, tmpreg) {
        if (!tmpreg) {
            continue;
        }
        memcpy(arch_regs[regnum].name, tmpreg->name, sizeof(tmpreg->name));
        arch_regs[regnum].size = tmpreg->size;
        arch_regs[regnum].offset = regoff;
        if (profile_len + 128 >= profile_max_len) {
            if (!(tmp = realloc(profile, profile_max_len + 512))) {
                goto exit_err;
            }
            profile = tmp;
            profile_max_len += 512;
        }
        flag_bits[0] = '\0';
        tmpflag = NULL;
        if (tmpreg->flagnum < rz_list_length(flags)) {
            tmpflag = rz_list_get_n(flags, tmpreg->flagnum);
            _write_flag_bits(flag_bits, tmpflag);
        }
        packed_size = 0;
        if (tmpreg->size >= 64 &&
            (strstr(tmpreg->type, "fpu") ||
                strstr(tmpreg->type, "mmx") ||
                strstr(tmpreg->type, "xmm") ||
                strstr(tmpreg->type, "ymm"))) {
            packed_size = tmpreg->size / 8;
        }
        profile_len += snprintf(profile + profile_len, 128,
            "%s\t%s\t.%u\t.%" PFMT64d "\t%d\t%s\n", tmpreg->type,
            tmpreg->name, tmpreg->size, regoff,
            packed_size,
            flag_bits);
        // TODO write flag subregisters
        if (tmpflag) {
            int i;
            for (i = 0; i < tmpflag->num_fields; i++) {
                if (profile_len + 128 >= profile_max_len) {
                    if (!(tmp = realloc(profile, profile_max_len + 512))) {
                        goto exit_err;
                    }
                    profile = tmp;
                    profile_max_len += 512;
                }
                profile_len += snprintf(profile + profile_len, 128, "gpr\t%s\t"
                                            ".%u\t.%" PFMT64d "\t0\n",
                    tmpflag->fields[i].name,
                    tmpflag->fields[i].sz, tmpflag->fields[i].bit_num + regoff);
            }
        }
        regnum++;
        regoff += tmpreg->size;
    }
    // Difficult to parse these out from xml. So manually added from gdb's xml files
    switch (g->target.arch) {
    case RZ_SYS_ARCH_ARM:
        switch (g->target.bits) {
        case 32:
            if (!(profile = rz_str_prepend(profile,
                      "=PC  pc\n"
                      "=SP  sp\n" // XXX
                      "=A0  r0\n"
                      "=A1  r1\n"
                      "=A2  r2\n"
                      "=A3  r3\n"))) {
                goto exit_err;
            }
            break;
        case 64:
            if (!(profile = rz_str_prepend(profile,
                      "=PC  pc\n"
                      "=SP  sp\n"
                      "=BP  x29\n"
                      "=A0  x0\n"
                      "=A1  x1\n"
                      "=A2  x2\n"
                      "=A3  x3\n"
                      "=ZF  zf\n"
                      "=SF  nf\n"
                      "=OF  vf\n"
                      "=CF  cf\n"
                      "=SN  x8\n"))) {
                goto exit_err;
            }
        }
        break;
    case RZ_SYS_ARCH_X86:
        switch (g->target.bits) {
        case 32:
            if (!(profile = rz_str_prepend(profile,
                      "=PC  eip\n"
                      "=SP  esp\n"
                      "=BP  ebp\n"))) {
                goto exit_err;
            }
            break;
        case 64:
            if (!(profile = rz_str_prepend(profile,
                      "=PC  rip\n"
                      "=SP  rsp\n"
                      "=BP  rbp\n"))) {
                goto exit_err;
            }
        }
        break;
    case RZ_SYS_ARCH_MIPS:
        if (!(profile = rz_str_prepend(profile,
                  "=PC  pc\n"
                  "=SP  r29\n"))) {
            goto exit_err;
        }
        break;
    default:
        // TODO others
        if (*pc_alias) {
            if (!(profile = rz_str_prepend(profile, pc_alias))) {
                goto exit_err;
            }
        }
    }
    // Special case for MIPS, since profile doesn't separate 32/64 bit MIPS
    if (g->target.arch == RZ_SYS_ARCH_MIPS) {
        if (arch_regs && arch_regs[0].size == 8) {
            g->target.bits = 64;
        }
    }
    rz_list_free(flags);
    rz_list_free(regs);
    RZ_FREE(g->target.regprofile);
    if (profile) {
        g->target.regprofile = strdup(profile);
        free(profile);
    }
    g->target.valid = true;
    g->registers = arch_regs;
    return 0;
 
exit_err:
    rz_list_free(flags);
    rz_list_free(regs);
    free(profile);
    free(arch_regs);
    return -1;
}
 
/* Reference:
<osdata type="processes">
<item>
<column name="pid">1</column>
<column name="user">root</column>
<column name="command">/sbin/init maybe-ubiquity </column>
<column name="cores">0</column>
</item>
</osdata>
*/
static int gdbr_parse_processes_xml(libgdbr_t *g, char *xml_data, ut64 len, int pid, RzList *list) {
    char pidstr[MAX_PID_CHARS + 1], status[1024], cmdline[1024];
    char *itemstr, *column, *column_end, *proc_filename;
    int ret = -1, ipid, column_data_len;
    RzDebugPid *pid_info = NULL;
 
    // Make sure the given xml is valid
    if (!rz_str_startswith(xml_data, "<osdata type=\"processes\">")) {
        ret = -1;
        goto end;
    }
 
    column = xml_data;
    while ((itemstr = strstr(column, "<item>"))) {
        if (!strstr(itemstr, "</item>")) {
            ret = -1;
            goto end;
        }
        // Get PID
        if (!(column = strstr(itemstr, "<column name=\"pid\">"))) {
            ret = -1;
            goto end;
        }
        if (!(column_end = strstr(column, "</column>"))) {
            ret = -1;
            goto end;
        }
 
        column += sizeof("<column name=\"pid\">") - 1;
        column_data_len = column_end - column;
 
        memcpy(pidstr, column, column_data_len);
        pidstr[column_data_len] = '\0';
 
        ipid = atoi(pidstr);
 
        // Get cmdline
        if (!(column = strstr(itemstr, "<column name=\"command\">"))) {
            ret = -1;
            goto end;
        }
        if (!(column_end = strstr(column, "</column>"))) {
            ret = -1;
            goto end;
        }
 
        column += sizeof("<column name=\"command\">") - 1;
        column_data_len = column_end - column;
 
        memcpy(cmdline, column, column_data_len);
        cmdline[column_data_len] = '\0';
 
        // Attempt to read the pid's info from /proc. Non UNIX systems will have the
        // correct pid and cmdline from the xml with everything else set to default
        proc_filename = rz_str_newf("/proc/%d/status", ipid);
        if (gdbr_open_file(g, proc_filename, O_RDONLY, 0) == 0) {
            if (gdbr_read_file(g, (unsigned char *)status, sizeof(status)) != -1) {
                pid_info = _extract_pid_info(status, cmdline, ipid);
            } else {
                eprintf("Failed to read from data from procfs file of pid (%d)\n", ipid);
            }
            if (gdbr_close_file(g) != 0) {
                eprintf("Failed to close procfs file of pid (%d)\n", ipid);
            }
        } else {
            eprintf("Failed to open procfs file of pid (%d)\n", ipid);
            if (!(pid_info = RZ_NEW0(RzDebugPid)) || !(pid_info->path = strdup(cmdline))) {
                ret = -1;
                goto end;
            }
            pid_info->pid = ipid;
            pid_info->ppid = 0;
            pid_info->uid = pid_info->gid = -1;
            pid_info->runnable = true;
            pid_info->status = RZ_DBG_PROC_STOP;
        }
        // Unless pid 0 is requested, only add the requested pid and it's child processes
        if (0 == pid || ipid == pid || pid_info->ppid == pid) {
            rz_list_append(list, pid_info);
        } else {
            if (pid_info) {
                free(pid_info);
                pid_info = NULL;
            }
        }
    }
 
    ret = 0;
end:
    if (ret != 0) {
        if (pid_info) {
            free(pid_info);
        }
    }
    return ret;
}
 
// If xml target description is supported, read it
int gdbr_read_target_xml(libgdbr_t *g) {
    if (!g->stub_features.qXfer_features_read) {
        return -1;
    }
    char *data;
    ut64 len;
    if (!(data = gdbr_read_feature(g, "target.xml", &len))) {
        return -1;
    }
    gdbr_parse_target_xml(g, data, len);
    free(data);
    return 0;
}
 
int gdbr_read_processes_xml(libgdbr_t *g, int pid, RzList *list) {
    if (!g->stub_features.qXfer_features_read) {
        return -1;
    }
    ut64 len;
    int ret = -1;
    char *data;
 
    if (!(data = gdbr_read_osdata(g, "processes", &len))) {
        ret = -1;
        goto end;
    }
 
    if (gdbr_parse_processes_xml(g, data, len, pid, list) != 0) {
        ret = -1;
        goto end;
    }
 
    ret = 0;
end:
    if (data) {
        free(data);
    }
    return ret;
}
 
// sizeof (buf) needs to be atleast flags->num_bits + 1
static void _write_flag_bits(char *buf, const gdbr_xml_flags_t *flags) {
    bool fc[26] = { false };
    ut32 i, c;
    memset(buf, '.', flags->num_bits);
    buf[flags->num_bits] = '\0';
    for (i = 0; i < flags->num_fields; i++) {
        // How do we show multi-bit flags?
        if (flags->fields[i].sz != 1) {
            continue;
        }
        // To avoid duplicates. This skips flags if first char is same. i.e.
        // for x86_64, it will skip VIF because VM already occurred. This is
        // same as default reg-profiles in r2
        c = tolower(flags->fields[i].name[0]) - 'a';
        if (fc[c]) {
            continue;
        }
        fc[c] = true;
        buf[flags->fields[i].bit_num] = 'a' + c;
    }
}
 
static int _resolve_arch(libgdbr_t *g, char *xml_data) {
    char *arch;
    // Find architecture
    g->target.arch = RZ_SYS_ARCH_NONE;
    if ((arch = strstr(xml_data, "<architecture"))) {
        if (!(arch = strchr(arch, '>'))) {
            return -1;
        }
        arch++;
        if (rz_str_startswith(arch, "i386")) {
            g->target.arch = RZ_SYS_ARCH_X86;
            g->target.bits = 32;
            arch += 4;
            if (rz_str_startswith(arch, ":x86-64")) {
                g->target.bits = 64;
            }
        } else if (rz_str_startswith(arch, "aarch64")) {
            g->target.arch = RZ_SYS_ARCH_ARM;
            g->target.bits = 64;
        } else if (rz_str_startswith(arch, "arm")) {
            g->target.arch = RZ_SYS_ARCH_ARM;
            g->target.bits = 32;
        } else if (rz_str_startswith(arch, "mips")) {
            g->target.arch = RZ_SYS_ARCH_MIPS;
            g->target.bits = 32;
        }
        // TODO others
    } else {
        // apple's debugserver on ios9
        if (strstr(xml_data, "com.apple.debugserver.arm64")) {
            g->target.arch = RZ_SYS_ARCH_ARM;
            g->target.bits = 64;
        } else if (strstr(xml_data, "org.gnu.gdb.riscv")) {
            g->target.arch = RZ_SYS_ARCH_RISCV;
            g->target.bits = 64;
        } else if (strstr(xml_data, "org.gnu.gdb.mips")) {
            // openocd mips?
            g->target.arch = RZ_SYS_ARCH_MIPS;
            g->target.bits = 32;
        } else if (strstr(xml_data, "com.apple.debugserver.x86_64")) {
            g->target.arch = RZ_SYS_ARCH_X86;
            g->target.bits = 64;
        } else {
            eprintf("Warning: Unknown architecture parsing XML (%s)\n", xml_data);
        }
    }
    return 0;
}
 
static RzList *_extract_flags(char *flagstr) {
    char *tmp1, *tmp2, *flagsend, *field_start, *field_end;
    ut64 num_fields, type_sz, name_sz;
    gdbr_xml_flags_t *tmpflag = NULL;
    RzList *flags;
    if (!(flags = rz_list_new())) {
        return NULL;
    }
    flags->free = free;
    while ((flagstr = strstr(flagstr, "<flags"))) {
        if (!(flagsend = strstr(flagstr, "</flags>"))) {
            goto exit_err;
        }
        *flagsend = '\0';
        if (!(tmpflag = calloc(1, sizeof(gdbr_xml_flags_t)))) {
            goto exit_err;
        }
        // Get id
        if (!(tmp1 = strstr(flagstr, "id="))) {
            goto exit_err;
        }
        tmp1 += 4;
        if (!(tmp2 = strchr(tmp1, '"'))) {
            goto exit_err;
        }
        *tmp2 = '\0';
        type_sz = sizeof(tmpflag->type);
        strncpy(tmpflag->type, tmp1, type_sz - 1);
        tmpflag->type[type_sz - 1] = '\0';
        *tmp2 = '"';
        // Get size of flags register
        if (!(tmp1 = strstr(flagstr, "size="))) {
            goto exit_err;
        }
        tmp1 += 6;
        if (!(tmpflag->num_bits = (ut32)strtoul(tmp1, NULL, 10))) {
            goto exit_err;
        }
        tmpflag->num_bits *= 8;
        // Get fields
        num_fields = 0;
        field_start = flagstr;
        while ((field_start = strstr(field_start, "<field"))) {
            // Max 64 fields
            if (num_fields >= 64) {
                break;
            }
            if (!(field_end = strstr(field_start, "/>"))) {
                goto exit_err;
            }
            *field_end = '\0';
            // Get name
            if (!(tmp1 = strstr(field_start, "name="))) {
                goto exit_err;
            }
            tmp1 += 6;
            if (!(tmp2 = strchr(tmp1, '"'))) {
                goto exit_err;
            }
            // If name length is 0, it is a 1 field. Don't include
            if (tmp2 - tmp1 <= 1) {
                *field_end = '/';
                field_start = field_end + 1;
                continue;
            }
            *tmp2 = '\0';
            name_sz = sizeof(tmpflag->fields[num_fields].name);
            strncpy(tmpflag->fields[num_fields].name, tmp1, name_sz - 1);
            tmpflag->fields[num_fields].name[name_sz - 1] = '\0';
            *tmp2 = '"';
            // Get offset
            if (!(tmp1 = strstr(field_start, "start="))) {
                goto exit_err;
            }
            tmp1 += 7;
            if (!isdigit(*tmp1)) {
                goto exit_err;
            }
            tmpflag->fields[num_fields].bit_num = (ut32)strtoul(tmp1, NULL, 10);
            // Get end
            if (!(tmp1 = strstr(field_start, "end="))) {
                goto exit_err;
            }
            tmp1 += 5;
            if (!isdigit(*tmp1)) {
                goto exit_err;
            }
            tmpflag->fields[num_fields].sz = (ut32)strtoul(tmp1, NULL, 10) + 1;
            tmpflag->fields[num_fields].sz -= tmpflag->fields[num_fields].bit_num;
            num_fields++;
            *field_end = '/';
            field_start = field_end + 1;
        }
        tmpflag->num_fields = num_fields;
        rz_list_push(flags, tmpflag);
        *flagsend = '<';
        flagstr = flagsend + 1;
    }
    return flags;
exit_err:
    if (flags) {
        rz_list_free(flags);
    }
    free(tmpflag);
    return NULL;
}
 
static RzDebugPid *_extract_pid_info(const char *info, const char *path, int tid) {
    RzDebugPid *pid_info = RZ_NEW0(RzDebugPid);
    if (!pid_info) {
        return NULL;
    }
    char *ptr = strstr(info, "State:");
    if (ptr) {
        switch (*(ptr + 7)) {
        case 'R':
            pid_info->status = RZ_DBG_PROC_RUN;
            break;
        case 'S':
            pid_info->status = RZ_DBG_PROC_SLEEP;
            break;
        case 'T':
        case 't':
            pid_info->status = RZ_DBG_PROC_STOP;
            break;
        case 'Z':
            pid_info->status = RZ_DBG_PROC_ZOMBIE;
            break;
        case 'X':
            pid_info->status = RZ_DBG_PROC_DEAD;
            break;
        default:
            pid_info->status = RZ_DBG_PROC_SLEEP;
            break;
        }
    }
    ptr = strstr(info, "PPid:");
    if (ptr) {
        pid_info->ppid = atoi(ptr + 5);
    }
    ptr = strstr(info, "Uid:");
    if (ptr) {
        pid_info->uid = atoi(ptr + 5);
    }
    ptr = strstr(info, "Gid:");
    if (ptr) {
        pid_info->gid = atoi(ptr + 5);
    }
    pid_info->pid = tid;
    pid_info->path = path ? strdup(path) : NULL;
    pid_info->runnable = true;
    pid_info->pc = 0;
    return pid_info;
}
 
static RzList *_extract_regs(char *regstr, RzList *flags, char *pc_alias) {
    char *regstr_end, *regname, *regtype, *tmp1, *tmpregstr, *feature_end, *typegroup, *feature_start;
    ut32 flagnum, regname_len, regsize, regnum;
    RzList *regs;
    RzListIter *iter;
    gdbr_xml_reg_t *tmpreg;
    gdbr_xml_flags_t *tmpflag;
    if (!(regs = rz_list_new())) {
        return NULL;
    }
    // Set gpr as the default register type for all of the following registers until `feature` is found
    typegroup = "gpr";
    while ((tmpregstr = strstr(regstr, "<reg"))) {
        if (!(regstr_end = strchr(tmpregstr, '/'))) {
            goto exit_err;
        }
        // Most regs don't have group/type params, attempt to get the type from `feature`.
        // Multiple registers can be wrapped with a certain feature so this typegroup
        // applies on all of the following registers until </feature>
        if ((feature_start = strstr(regstr, "<feature")) && feature_start < tmpregstr) {
            // Verify that we found the feature in the current node
            regstr = feature_start;
            feature_end = strchr(regstr, '>');
            // To parse features of other architectures refer to:
            // https://sourceware.org/gdb/onlinedocs/gdb/Standard-Target-Features.html#Standard-Target-Features
            // - x86
            if ((tmp1 = strstr(regstr, "core")) != NULL && tmp1 < feature_end) {
                typegroup = "gpr";
            } else if ((tmp1 = strstr(regstr, "segments")) != NULL && tmp1 < feature_end) {
                typegroup = "seg";
            } else if ((tmp1 = strstr(regstr, "linux")) != NULL && tmp1 < feature_end) {
                typegroup = "gpr";
                // Includes avx.512
            } else if ((tmp1 = strstr(regstr, "avx")) != NULL && tmp1 < feature_end) {
                typegroup = "ymm";
            } else if ((tmp1 = strstr(regstr, "mpx")) != NULL && tmp1 < feature_end) {
                typegroup = "seg";
                // - arm
            } else if ((tmp1 = strstr(regstr, "m-profile")) != NULL && tmp1 < feature_end) {
                typegroup = "gpr";
            } else if ((tmp1 = strstr(regstr, "pfe")) != NULL && tmp1 < feature_end) {
                typegroup = "fpu";
            } else if ((tmp1 = strstr(regstr, "vfp")) != NULL && tmp1 < feature_end) {
                typegroup = "fpu";
            } else if ((tmp1 = strstr(regstr, "iwmmxt")) != NULL && tmp1 < feature_end) {
                typegroup = "xmm";
                // -- Aarch64
            } else if ((tmp1 = strstr(regstr, "sve")) != NULL && tmp1 < feature_end) {
                typegroup = "ymm";
            } else if ((tmp1 = strstr(regstr, "pauth")) != NULL && tmp1 < feature_end) {
                typegroup = "sec";
            } else if ((tmp1 = strstr(regstr, "qemu")) != NULL && tmp1 < feature_end) {
                // - QEMU server registers
                typegroup = "sys";
            } else {
                typegroup = "gpr";
            }
        }
        // Reset to typegroup in case the previous register had a group/type parameter
        // that indicated it's specific type which doesn't correspond to type defined by
        // the parent feature tag
        regtype = typegroup;
        regstr = tmpregstr;
        *regstr_end = '\0';
        // name
        if (!(regname = strstr(regstr, "name="))) {
            goto exit_err;
        }
        regname += 6;
        if (!(tmp1 = strchr(regname, '"'))) {
            goto exit_err;
        }
        regname_len = tmp1 - regname;
        // size
        if (!(tmp1 = strstr(regstr, "bitsize="))) {
            goto exit_err;
        }
        tmp1 += 9;
        if (!isdigit(*tmp1)) {
            goto exit_err;
        }
        regsize = strtoul(tmp1, NULL, 10);
        // regnum
        regnum = UINT32_MAX;
        if ((tmp1 = strstr(regstr, "regnum="))) {
            tmp1 += 8;
            if (!isdigit(*tmp1)) {
                goto exit_err;
            }
            regnum = strtoul(tmp1, NULL, 10);
        }
        flagnum = rz_list_length(flags);
        if ((tmp1 = strstr(regstr, "group="))) {
            tmp1 += 7;
            if (rz_str_startswith(tmp1, "float")) {
                regtype = "fpu";
            } else if (rz_str_startswith(tmp1, "mmx")) {
                regtype = "mmx";
            } else if (rz_str_startswith(tmp1, "sse")) {
                regtype = "xmm";
            } else if (rz_str_startswith(tmp1, "vector")) {
                regtype = "ymm";
            } else if (rz_str_startswith(tmp1, "system")) {
                regtype = "seg";
            }
            // We need type information in r2 register profiles
        }
        if ((tmp1 = strstr(regstr, "type="))) {
            tmp1 += 6;
            if (rz_str_startswith(tmp1, "vec") || rz_str_startswith(tmp1, "i387_ext") || rz_str_startswith(tmp1, "ieee_single") || rz_str_startswith(tmp1, "ieee_double")) {
                regtype = "fpu";
            } else if (rz_str_startswith(tmp1, "code_ptr")) {
                strcpy(pc_alias, "=PC   ");
                strncpy(pc_alias + 4, regname, regname_len);
                strcpy(pc_alias + 4 + regname_len, "\n");
            } else {
                // Check all flags. If reg is a flag, write flag data
                flagnum = 0;
                rz_list_foreach (flags, iter, tmpflag) {
                    if (rz_str_startswith(tmp1, tmpflag->type)) {
                        // Max 64-bit :/
                        if (tmpflag->num_bits <= 64) {
                            break;
                        }
                    }
                    flagnum++;
                }
            }
            // We need type information in r2 register profiles
        }
        // Move unidentified vector/large registers from gpr to xmm since r2 set/get
        // registers doesn't support >64bit registers atm(but it's still possible to
        // read them using gdbr's implementation through dr/drt)
        if (regsize > 64 && !strcmp(regtype, "gpr")) {
            regtype = "xmm";
        }
        // Move appropriately sized unidentified xmm registers from fpu to xmm
        if (regsize == 128 && !strcmp(regtype, "fpu")) {
            regtype = "xmm";
        }
        if (!(tmpreg = calloc(1, sizeof(gdbr_xml_reg_t)))) {
            goto exit_err;
        }
        regname[regname_len] = '\0';
        if (regname_len > sizeof(tmpreg->name) - 1) {
            eprintf("Register name too long: %s\n", regname);
        }
        strncpy(tmpreg->name, regname, sizeof(tmpreg->name) - 1);
        tmpreg->name[sizeof(tmpreg->name) - 1] = '\0';
        regname[regname_len] = '"';
        strncpy(tmpreg->type, regtype, sizeof(tmpreg->type) - 1);
        tmpreg->type[sizeof(tmpreg->type) - 1] = '\0';
        tmpreg->size = regsize;
        tmpreg->flagnum = flagnum;
        if (regnum == UINT32_MAX) {
            rz_list_push(regs, tmpreg);
        } else if (regnum >= rz_list_length(regs)) {
            int i;
            for (i = regnum - rz_list_length(regs); i > 0; i--) {
                // temporary placeholder reg. we trust the xml is correct and this will be replaced.
                rz_list_push(regs, tmpreg);
                rz_list_tail(regs)->data = NULL;
            }
            rz_list_push(regs, tmpreg);
        } else {
            // this is where we replace those placeholder regs
            rz_list_set_n(regs, regnum, tmpreg);
        }
        *regstr_end = '/';
        regstr = regstr_end + 3;
        if (rz_str_startswith(regstr, "</feature>")) {
            regstr += sizeof("</feature>");
            // Revert to default
            typegroup = "gpr";
        }
    }
    regs->free = free;
    return regs;
exit_err:
    if (regs) {
        regs->free = free;
        rz_list_free(regs);
    }
    return NULL;
}