X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Ftarget%2Fregister.c;h=638747560cb08f9c66762477c84ef0fa2220db6d;hp=8bffe482f742642c614054c565eb6664f6e23228;hb=HEAD;hpb=86173cdbddde781b19ac630602f2d450a59b32b5 diff --git a/src/target/register.c b/src/target/register.c index 8bffe482f7..e4f22f8e93 100644 --- a/src/target/register.c +++ b/src/target/register.c @@ -1,60 +1,77 @@ +// SPDX-License-Identifier: GPL-2.0-or-later + /*************************************************************************** * Copyright (C) 2005 by Dominic Rath * * Dominic.Rath@gmx.de * * * - * Copyright (C) 2007,2008 Øyvind Harboe * + * Copyright (C) 2007,2008 Øyvind Harboe * * oyvind.harboe@zylin.com * - * * - * This program is free software; you can redistribute it and/or modify * - * it under the terms of the GNU General Public License as published by * - * the Free Software Foundation; either version 2 of the License, or * - * (at your option) any later version. * - * * - * This program is distributed in the hope that it will be useful, * - * but WITHOUT ANY WARRANTY; without even the implied warranty of * - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * - * GNU General Public License for more details. * - * * - * You should have received a copy of the GNU General Public License * - * along with this program; if not, write to the * - * Free Software Foundation, Inc., * - * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ***************************************************************************/ + #ifdef HAVE_CONFIG_H #include "config.h" #endif #include "register.h" -#include "log.h" +#include + +/** + * @file + * Holds utilities to work with register caches. + * + * OpenOCD uses machine registers internally, and exposes them by name + * to Tcl scripts. Sets of related registers are grouped into caches. + * For example, a CPU core will expose a set of registers, and there + * may be separate registers associated with debug or trace modules. + */ + +struct reg *register_get_by_number(struct reg_cache *first, + uint32_t reg_num, bool search_all) +{ + struct reg_cache *cache = first; + while (cache) { + for (unsigned int i = 0; i < cache->num_regs; i++) { + if (!cache->reg_list[i].exist) + continue; + if (cache->reg_list[i].number == reg_num) + return &(cache->reg_list[i]); + } + + if (!search_all) + break; + + cache = cache->next; + } -reg_arch_type_t *reg_arch_types = NULL; + return NULL; +} -reg_t* register_get_by_name(reg_cache_t *first, char *name, int search_all) +struct reg *register_get_by_name(struct reg_cache *first, + const char *name, bool search_all) { - int i; - reg_cache_t *cache = first; + struct reg_cache *cache = first; - while (cache) - { - for (i = 0; i < cache->num_regs; i++) - { + while (cache) { + for (unsigned int i = 0; i < cache->num_regs; i++) { + if (!cache->reg_list[i].exist) + continue; if (strcmp(cache->reg_list[i].name, name) == 0) return &(cache->reg_list[i]); } - if (search_all) - cache = cache->next; - else + if (!search_all) break; + + cache = cache->next; } return NULL; } -reg_cache_t** register_get_last_cache_p(reg_cache_t **first) +struct reg_cache **register_get_last_cache_p(struct reg_cache **first) { - reg_cache_t **cache_p = first; + struct reg_cache **cache_p = first; if (*cache_p) while (*cache_p) @@ -65,62 +82,45 @@ reg_cache_t** register_get_last_cache_p(reg_cache_t **first) return cache_p; } -int register_reg_arch_type(int (*get)(reg_t *reg), int (*set)(reg_t *reg, uint8_t *buf)) +void register_unlink_cache(struct reg_cache **cache_p, const struct reg_cache *cache) { - reg_arch_type_t** arch_type_p = ®_arch_types; - int id = 0; - - if (*arch_type_p) - { - while (*arch_type_p) - { - id = (*arch_type_p)->id; - arch_type_p = &((*arch_type_p)->next); - } - } - - (*arch_type_p) = malloc(sizeof(reg_arch_type_t)); - (*arch_type_p)->id = id + 1; - (*arch_type_p)->set = set; - (*arch_type_p)->get = get; - (*arch_type_p)->next = NULL; - - return id + 1; + while (*cache_p && *cache_p != cache) + cache_p = &((*cache_p)->next); + if (*cache_p) + *cache_p = cache->next; } -reg_arch_type_t* register_get_arch_type(int id) +/** Marks the contents of the register cache as invalid (and clean). */ +void register_cache_invalidate(struct reg_cache *cache) { - reg_arch_type_t *arch_type = reg_arch_types; - - while (arch_type) - { - if (arch_type->id == id) - return arch_type; - arch_type = arch_type->next; + for (unsigned int n = 0; n < cache->num_regs; n++) { + struct reg *reg = &cache->reg_list[n]; + if (!reg->exist) + continue; + reg->valid = false; + reg->dirty = false; } - LOG_ERROR("BUG: encountered unregistered arch type 0x%08x", id); - exit(-1); - return NULL; } -static int register_get_dummy_core_reg(reg_t *reg) +static int register_get_dummy_core_reg(struct reg *reg) { return ERROR_OK; } -static int register_set_dummy_core_reg(reg_t *reg, uint8_t *buf) +static int register_set_dummy_core_reg(struct reg *reg, uint8_t *buf) { - reg->dirty = 1; - reg->valid = 1; + reg->dirty = true; + reg->valid = true; return ERROR_OK; } -void register_init_dummy(reg_t *reg) -{ - static int dummy_arch_type = -1; - if (dummy_arch_type == -1 ) - dummy_arch_type = register_reg_arch_type(register_get_dummy_core_reg, register_set_dummy_core_reg); +static const struct reg_arch_type dummy_type = { + .get = register_get_dummy_core_reg, + .set = register_set_dummy_core_reg, +}; - reg->arch_type = dummy_arch_type; +void register_init_dummy(struct reg *reg) +{ + reg->type = &dummy_type; }