LXR qemu/target/cris/gdbstub.c

   1/*
   2 * CRIS gdb server stub
   3 *
   4 * Copyright (c) 2003-2005 Fabrice Bellard
   5 * Copyright (c) 2013 SUSE LINUX Products GmbH
   6 *
   7 * This library is free software; you can redistribute it and/or
   8 * modify it under the terms of the GNU Lesser General Public
   9 * License as published by the Free Software Foundation; either
  10 * version 2 of the License, or (at your option) any later version.
  11 *
  12 * This library is distributed in the hope that it will be useful,
  13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 * Lesser General Public License for more details.
  16 *
  17 * You should have received a copy of the GNU Lesser General Public
  18 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  19 */
  20#include "qemu/osdep.h"
  21#include "qemu-common.h"
  22#include "cpu.h"
  23#include "exec/gdbstub.h"
  24
  25int crisv10_cpu_gdb_read_register(CPUState *cs, uint8_t *mem_buf, int n)
  26{
  27    CRISCPU *cpu = CRIS_CPU(cs);
  28    CPUCRISState *env = &cpu->env;
  29
  30    if (n < 15) {
  31        return gdb_get_reg32(mem_buf, env->regs[n]);
  32    }
  33
  34    if (n == 15) {
  35        return gdb_get_reg32(mem_buf, env->pc);
  36    }
  37
  38    if (n < 32) {
  39        switch (n) {
  40        case 16:
  41            return gdb_get_reg8(mem_buf, env->pregs[n - 16]);
  42        case 17:
  43            return gdb_get_reg8(mem_buf, env->pregs[n - 16]);
  44        case 20:
  45        case 21:
  46            return gdb_get_reg16(mem_buf, env->pregs[n - 16]);
  47        default:
  48            if (n >= 23) {
  49                return gdb_get_reg32(mem_buf, env->pregs[n - 16]);
  50            }
  51            break;
  52        }
  53    }
  54    return 0;
  55}
  56
  57int cris_cpu_gdb_read_register(CPUState *cs, uint8_t *mem_buf, int n)
  58{
  59    CRISCPU *cpu = CRIS_CPU(cs);
  60    CPUCRISState *env = &cpu->env;
  61    uint8_t srs;
  62
  63    srs = env->pregs[PR_SRS];
  64    if (n < 16) {
  65        return gdb_get_reg32(mem_buf, env->regs[n]);
  66    }
  67
  68    if (n >= 21 && n < 32) {
  69        return gdb_get_reg32(mem_buf, env->pregs[n - 16]);
  70    }
  71    if (n >= 33 && n < 49) {
  72        return gdb_get_reg32(mem_buf, env->sregs[srs][n - 33]);
  73    }
  74    switch (n) {
  75    case 16:
  76        return gdb_get_reg8(mem_buf, env->pregs[0]);
  77    case 17:
  78        return gdb_get_reg8(mem_buf, env->pregs[1]);
  79    case 18:
  80        return gdb_get_reg32(mem_buf, env->pregs[2]);
  81    case 19:
  82        return gdb_get_reg8(mem_buf, srs);
  83    case 20:
  84        return gdb_get_reg16(mem_buf, env->pregs[4]);
  85    case 32:
  86        return gdb_get_reg32(mem_buf, env->pc);
  87    }
  88
  89    return 0;
  90}
  91
  92int cris_cpu_gdb_write_register(CPUState *cs, uint8_t *mem_buf, int n)
  93{
  94    CRISCPU *cpu = CRIS_CPU(cs);
  95    CPUCRISState *env = &cpu->env;
  96    uint32_t tmp;
  97
  98    if (n > 49) {
  99        return 0;
 100    }
 101
 102    tmp = ldl_p(mem_buf);
 103
 104    if (n < 16) {
 105        env->regs[n] = tmp;
 106    }
 107
 108    if (n >= 21 && n < 32) {
 109        env->pregs[n - 16] = tmp;
 110    }
 111
 112    /* FIXME: Should support function regs be writable?  */
 113    switch (n) {
 114    case 16:
 115        return 1;
 116    case 17:
 117        return 1;
 118    case 18:
 119        env->pregs[PR_PID] = tmp;
 120        break;
 121    case 19:
 122        return 1;
 123    case 20:
 124        return 2;
 125    case 32:
 126        env->pc = tmp;
 127        break;
 128    }
 129
 130    return 4;
 131}
 132