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.1 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 "cpu.h"
  22 #include "gdbstub/helpers.h"
  23
  24 int crisv10_cpu_gdb_read_register(CPUState *cs, GByteArray *mem_buf, int n)
  25 {
  26     CPUCRISState *env = cpu_env(cs);
  27
  28     if (n < 15) {
  29         return gdb_get_reg32(mem_buf, env->regs[n]);
  30     }
  31
  32     if (n == 15) {
  33         return gdb_get_reg32(mem_buf, env->pc);
  34     }
  35
  36     if (n < 32) {
  37         switch (n) {
  38         case 16:
  39             return gdb_get_reg8(mem_buf, env->pregs[n - 16]);
  40         case 17:
  41             return gdb_get_reg8(mem_buf, env->pregs[n - 16]);
  42         case 20:
  43         case 21:
  44             return gdb_get_reg16(mem_buf, env->pregs[n - 16]);
  45         default:
  46             if (n >= 23) {
  47                 return gdb_get_reg32(mem_buf, env->pregs[n - 16]);
  48             }
  49             break;
  50         }
  51     }
  52     return 0;
  53 }
  54
  55 int cris_cpu_gdb_read_register(CPUState *cs, GByteArray *mem_buf, int n)
  56 {
  57     CPUCRISState *env = cpu_env(cs);
  58     uint8_t srs;
  59
  60     srs = env->pregs[PR_SRS];
  61     if (n < 16) {
  62         return gdb_get_reg32(mem_buf, env->regs[n]);
  63     }
  64
  65     if (n >= 21 && n < 32) {
  66         return gdb_get_reg32(mem_buf, env->pregs[n - 16]);
  67     }
  68     if (n >= 33 && n < 49) {
  69         return gdb_get_reg32(mem_buf, env->sregs[srs][n - 33]);
  70     }
  71     switch (n) {
  72     case 16:
  73         return gdb_get_reg8(mem_buf, env->pregs[0]);
  74     case 17:
  75         return gdb_get_reg8(mem_buf, env->pregs[1]);
  76     case 18:
  77         return gdb_get_reg32(mem_buf, env->pregs[2]);
  78     case 19:
  79         return gdb_get_reg8(mem_buf, srs);
  80     case 20:
  81         return gdb_get_reg16(mem_buf, env->pregs[4]);
  82     case 32:
  83         return gdb_get_reg32(mem_buf, env->pc);
  84     }
  85
  86     return 0;
  87 }
  88
  89 int cris_cpu_gdb_write_register(CPUState *cs, uint8_t *mem_buf, int n)
  90 {
  91     CPUCRISState *env = cpu_env(cs);
  92     uint32_t tmp;
  93
  94     if (n > 49) {
  95         return 0;
  96     }
  97
  98     tmp = ldl_p(mem_buf);
  99
 100     if (n < 16) {
 101         env->regs[n] = tmp;
 102     }
 103
 104     if (n >= 21 && n < 32) {
 105         env->pregs[n - 16] = tmp;
 106     }
 107
 108     /* FIXME: Should support function regs be writable?  */
 109     switch (n) {
 110     case 16:
 111         return 1;
 112     case 17:
 113         return 1;
 114     case 18:
 115         env->pregs[PR_PID] = tmp;
 116         break;
 117     case 19:
 118         return 1;
 119     case 20:
 120         return 2;
 121     case 32:
 122         env->pc = tmp;
 123         break;
 124     }
 125
 126     return 4;
 127 }