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
  25 int 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
  57 int 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
  92 int 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 }