platform_profile.c

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2021 RizinOrg <info@rizin.re>
// SPDX-License-Identifier: LGPL-3.0-only
 
#include <rz_platform.h>
#include <string.h>
 
RZ_API void rz_platform_profile_free(RzPlatformProfile *p) {
    if (!p) {
        return;
    }
    ht_up_free(p->registers_mmio);
    ht_up_free(p->registers_extended);
    free(p);
}
 
static void free_mmio_kv(HtUPKv *kv) {
    free(kv->value);
}
 
RZ_API RZ_OWN RzPlatformProfile *rz_platform_profile_new() {
    RzPlatformProfile *profile = RZ_NEW0(RzPlatformProfile);
    if (!profile) {
        return NULL;
    }
    profile->registers_mmio = ht_up_new((HtUPDupValue)strdup, free_mmio_kv, (HtUPCalcSizeV)strlen);
    if (!profile->registers_mmio) {
        free(profile);
        return NULL;
    }
    profile->registers_extended = ht_up_new((HtUPDupValue)strdup, free_mmio_kv, (HtUPCalcSizeV)strlen);
    if (!profile->registers_extended) {
        ht_up_free(profile->registers_mmio);
        free(profile);
        return NULL;
    }
    return profile;
}
 
RZ_API RZ_OWN RzPlatformTarget *rz_platform_target_new() {
    RzPlatformTarget *profile = RZ_NEW0(RzPlatformTarget);
    if (!profile) {
        return NULL;
    }
    profile->profile = rz_platform_profile_new();
    if (!profile->profile) {
        free(profile);
        return NULL;
    }
    return profile;
}
 
RZ_API void rz_platform_target_free(RzPlatformTarget *t) {
    if (!t) {
        return;
    }
    rz_platform_profile_free(t->profile);
    free(t->cpu);
    free(t->arch);
    free(t);
}
 
RZ_API RZ_BORROW const char *rz_platform_profile_resolve_mmio(RZ_NONNULL RzPlatformProfile *profile, ut64 address) {
    rz_return_val_if_fail(profile, NULL);
 
    return ht_up_find(profile->registers_mmio, (ut64)address, NULL);
}
 
RZ_API RZ_BORROW const char *rz_platform_profile_resolve_extended_register(RZ_NONNULL RzPlatformProfile *profile, ut64 address) {
    rz_return_val_if_fail(profile, NULL);
 
    return ht_up_find(profile->registers_extended, (ut64)address, NULL);
}
 
static inline bool cpu_reload_needed(RzPlatformTarget *c, const char *cpu, const char *arch) {
    if (!c->arch || strcmp(c->arch, arch)) {
        return true;
    }
    return !c->cpu || strcmp(c->cpu, cpu);
}
 
static bool sdb_load_arch_profile(RzPlatformTarget *t, Sdb *sdb) {
    rz_return_val_if_fail(t && sdb, false);
    SdbKv *kv;
    SdbListIter *iter;
    RzPlatformProfile *c = rz_platform_profile_new();
    if (!c) {
        return false;
    }
    SdbList *l = sdb_foreach_list(sdb, false);
    ls_foreach (l, iter, kv) {
        if (!strcmp(sdbkv_key(kv), "PC")) {
            c->pc = rz_num_math(NULL, sdbkv_value(kv));
        } else if (!strcmp(sdbkv_key(kv), "EEPROM_SIZE")) {
            c->eeprom_size = rz_num_math(NULL, sdbkv_value(kv));
        } else if (!strcmp(sdbkv_key(kv), "IO_SIZE")) {
            c->io_size = rz_num_math(NULL, sdbkv_value(kv));
        } else if (!strcmp(sdbkv_key(kv), "SRAM_START")) {
            c->sram_start = rz_num_math(NULL, sdbkv_value(kv));
        } else if (!strcmp(sdbkv_key(kv), "SRAM_SIZE")) {
            c->sram_size = rz_num_math(NULL, sdbkv_value(kv));
        } else if (!strcmp(sdbkv_key(kv), "PAGE_SIZE")) {
            c->page_size = rz_num_math(NULL, sdbkv_value(kv));
        } else if (!strcmp(sdbkv_key(kv), "ROM_SIZE")) {
            c->rom_size = rz_num_math(NULL, sdbkv_value(kv));
        } else if (!strcmp(sdbkv_key(kv), "ROM_ADDRESS")) {
            c->rom_address = rz_num_math(NULL, sdbkv_value(kv));
        } else if (!strcmp(sdbkv_key(kv), "RAM_SIZE")) {
            c->ram_size = rz_num_math(NULL, sdbkv_value(kv));
        }
        if (!strcmp(sdbkv_value(kv), "io")) {
            char *io_name = sdbkv_key(kv);
            char *argument_key = rz_str_newf("%s.address", io_name);
            ut64 io_address = sdb_num_get(sdb, argument_key, NULL);
            free(argument_key);
            ht_up_insert(c->registers_mmio, io_address, io_name);
        }
        if (!strcmp(sdbkv_value(kv), "ext_io")) {
            char *ext_io_name = sdbkv_key(kv);
            char *argument_key = rz_str_newf("%s.address", ext_io_name);
            ut64 ext_io_address = sdb_num_get(sdb, argument_key, NULL);
            free(argument_key);
            ht_up_insert(c->registers_extended, ext_io_address, ext_io_name);
        }
    }
    ls_free(l);
    rz_platform_profile_free(t->profile);
    t->profile = c;
    return true;
}
 
static bool sdb_load_arch_profile_by_path(RZ_NONNULL RzPlatformTarget *t, const char *path) {
    Sdb *db = sdb_new(0, path, 0);
    bool result = sdb_load_arch_profile(t, db);
    sdb_close(db);
    sdb_free(db);
    return result;
}
 
RZ_API bool rz_platform_load_profile_sdb(RzPlatformTarget *t, const char *path) {
    if (!rz_file_exists(path)) {
        return false;
    }
    return sdb_load_arch_profile_by_path(t, path);
}
 
static bool is_cpu_valid(const char *cpu_dir, const char *cpu) {
    RzList *files = rz_sys_dir(cpu_dir);
    if (!files) {
        return false;
    }
    RzListIter *it;
    char *filename = NULL;
    char *arch_cpu = NULL;
 
    rz_list_foreach (files, it, filename) {
        char *cpu_name = NULL;
        if (!strcmp(filename, "..") || !strcmp(filename, "..")) {
            continue;
        }
        arch_cpu = rz_str_ndup(filename, strlen(filename) - 4);
        if (!arch_cpu) {
            continue;
        }
        cpu_name = strchr(arch_cpu, '-');
        if (!cpu_name) {
            free(arch_cpu);
            continue;
        }
        cpu_name[0] = '\0';
        if (!strcmp(cpu_name + 1, cpu)) {
            rz_list_free(files);
            free(arch_cpu);
            return true;
        }
 
        free(arch_cpu);
    }
 
    rz_list_free(files);
    return false;
}
 
RZ_API bool rz_platform_profiles_init(RzPlatformTarget *t, const char *cpu, const char *arch, const char *cpus_dir) {
    if (!cpu_reload_needed(t, cpu, arch)) {
        return false;
    }
    if (!cpus_dir || !arch || !cpu) {
        return false;
    }
    char buf[50];
    char *path = rz_file_path_join(cpus_dir, rz_strf(buf, "%s-%s.sdb", arch, cpu));
    if (!path) {
        return false;
    }
    if (!is_cpu_valid(cpus_dir, cpu)) {
        if (!strcmp(arch, "avr")) {
            free(path);
            path = rz_file_path_join(cpus_dir, "avr-ATmega8.sdb");
        }
    }
    free(t->cpu);
    free(t->arch);
    t->cpu = strdup(cpu);
    t->arch = strdup(arch);
    rz_platform_load_profile_sdb(t, path);
    free(path);
    return true;
}