OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [or1k-tdep.c] - Blame information for rev 116

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 104 markom 
/* Target-dependent code for the or1k architecture, for GDB, the GNU Debugger.
2 
   Copyright 1988-1999, Free Software Foundation, Inc.
3 
   Contributed by Alessandro Forin(af@cs.cmu.edu at CMU
4 
   and by Per Bothner(bothner@cs.wisc.edu) at U.Wisconsin.
5 
 
6 
   This file is part of GDB.
7 
 
8 
   This program is free software; you can redistribute it and/or modify
9 
   it under the terms of the GNU General Public License as published by
10 
   the Free Software Foundation; either version 2 of the License, or
11 
   (at your option) any later version.
12 
 
13 
   This program is distributed in the hope that it will be useful,
14 
   but WITHOUT ANY WARRANTY; without even the implied warranty of
15 
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 
   GNU General Public License for more details.
17 
 
18 
   You should have received a copy of the GNU General Public License
19 
   along with this program; if not, write to the Free Software
20 
   Foundation, Inc., 59 Temple Place - Suite 330,
21 
   Boston, MA 02111-1307, USA.  */
22 
 
23 
#include "defs.h"
24 
#include "gdb_string.h"
25 
#include "frame.h"
26 
#include "inferior.h"
27 
#include "symtab.h"
28 
#include "value.h"
29 
#include "gdbcmd.h"
30 
#include "language.h"
31 
#include "gdbcore.h"
32 
#include "symfile.h"
33 
#include "objfiles.h"
34 
#include "gdbtypes.h"
35 
#include "target.h"
36 
 
37 
#include "opcode/or32.h"
38 
 
39 
/* *INDENT-OFF* */
40 
 
41 
/* Group reg name size.  See or1k_reg_names.  */
42 
int or1k_group_name_sizes[OR1K_NUM_SPR_GROUPS] = {
43 115 markom 
  80,   0,   0, 6, 4, 2,
44 
  23, 16, 1, 3, 2, 8};
45 104 markom 
 
46 115 markom 
int or1k_group_name_start[OR1K_NUM_SPR_GROUPS] = {
47 
  0,   0,   0, 253, 254, 256,
48 
  32, 248, 16, 16, 255, 0};
49 
 
50 
/* Generated reg names (max valid alias index).
51 
   See or1k_spr_reg_name.  */
52 104 markom 
int or1k_spr_valid_aliases[OR1K_NUM_SPR_GROUPS] = {
53 115 markom 
  2047+1, 2047+1, 2047+1, 258+1, 257+1, 257+1,
54 
  79+1, 263+1, 16+1, 18+1, 256+1, 7+1};
55 104 markom 
 
56 
/* Register names.  */
57 
char *or1k_reg_names[] = {
58 115 markom 
  /* group 0 - general*/
59 
  "VR", "UPR", "CPUCFGR", "DMMUCFGR", "IMMUCFGR", "DCCFGR", "ICCFGR", "DCFGR",
60 
  "PCCFGR", "SPR0_9", "SPR0_10", "SPR0_11", "SPR0_12", "SPR0_13", "SPR0_14", "SPR0_15",
61 
  "PC", "SR", "SPR0_18", "SPR0_19", "SPR0_20", "SPR0_21", "SPR0_22", "SPR0_23",
62 104 markom 
  "EPCR0", "EPCR1", "EPCR2", "EPCR3", "EPCR4", "EPCR5", "EPCR6", "EPCR7",
63 
  "EPCR8", "EPCR9", "EPCR10", "EPCR11", "EPCR12", "EPCR13", "EPCR14", "EPCR15",
64 
  "EEAR0","EEAR1", "EEAR2", "EEAR3", "EEAR4", "EEAR5", "EEAR6", "EEAR7",
65 
  "EEAR8", "EEAR9", "EEAR10", "EEAR11", "EEAR12", "EEAR13", "EEAR14", "EEAR15",
66 
  "ESR0", "ESR1", "ESR2", "ESR3", "ESR4", "ESR5", "ESR6", "ESR7",
67 
  "ESR8", "ESR9", "ESR10", "ESR11", "ESR12", "ESR13", "ESR14", "ESR15",
68 113 markom 
  /* gpr+vf registers generated */
69 104 markom 
  /* group 1 - Data MMU - not listed, generated */
70 113 markom 
  /* group 2 - Instruction MMU - not listed, generated */
71 
  /* group 3 - Data cache */
72 115 markom 
  "DCCR", "DCBIR", "DCBPR", "DCBFR", "DCBWR", "DCBLR",
73 113 markom 
  /* group 4 - Instruction cache */
74 115 markom 
  "ICCR", "ICBLR", "ICBIR", "ICBPR",
75 113 markom 
  /* group 5 - MAC */
76 
  "MACLO", "MACHI",
77 104 markom 
  /* group 6 - debug */
78 
  "DVR0", "DVR1", "DVR2", "DVR3", "DVR4", "DVR5", "DVR6", "DVR7",
79 
  "DCR0", "DCR1", "DCR2", "DCR3", "DCR4", "DCR5", "DCR6", "DCR7",
80 115 markom 
  "DMR1", "DMR2", "DCWR0","DCWR1","DSR",  "DRR",  "DIR",
81 104 markom 
 
82 113 markom 
  /* group 7 - performance counters unit */
83 115 markom 
  "PCCM0", "PCMR1", "PCMR2", "PCMR3", "PCMR4", "PCMR5", "PCMR6", "PCMR7",
84 113 markom 
  "PCCR0", "PCCR1", "PCCR2", "PCCR3", "PCCR4", "PCCR5", "PCCR6", "PCCR7",
85 115 markom 
 
86 113 markom 
  /* group 8 - power management */
87 
  "PMR",
88 
 
89 
  /* group 9 - PIC */
90 
  "PICMR", "PICPR",
91 
 
92 
  /* group 10 - tick timer */
93 115 markom 
  "TTMR", "TTCR",
94 
 
95 
  /* group 11 - configureation */
96 
  "CPUCFGR", "DMMUCFGR", "IMMUCFGR", "DCCFGR", "ICCFGR", "SPR11_5", "DCFGR", "PCCFGR"
97 113 markom 
};
98 
 
99 
static char *or1k_gdb_reg_names[] = {
100 104 markom 
  /* general purpose registers */
101 
  "ZERO", "SP", "FP", "A0", "A1", "A2", "A3", "A4",
102 
  "A5", "LR", "R10", "RV", "R12", "R13", "R14", "R15",
103 
  "R16", "R17", "R18", "R19", "R20", "R21", "R22", "R23",
104 
  "R24", "R25", "R26", "R27", "R28", "R29", "R30", "R31",
105 
  /* vector/floating point registers */
106 
  "VFA0",  "VFA1",  "VFA2",  "VFA3",  "VFA4",  "VFA5",  "VFRV ", "VFR7",
107 113 markom 
  "VFR8",  "VFR9",  "VFR10", "VFR11", "VFR12", "VFR13", "VFR14", "VFR15",
108 104 markom 
  "VFR16", "VFR17", "VFR18", "VFR19", "VFR20", "VFR21", "VFR22", "VFR23",
109 113 markom 
  "VFR24", "VFR25", "VFR26", "VFR27", "VFR28", "VFR29", "VFR30", "VFR31",
110 
  "PC",    "SR",    "EPCR"
111 104 markom 
};
112 
 
113 
static char *or1k_group_names[] = {
114 
  "SYS", "DMMU", "IMMU", "DCACHE", "ICACHE", "MAC", "DEBUG", "PERF", "POWER",
115 
  "PIC", "TIMER"
116 
};
117 113 markom 
/* Table of or1k signals.  */
118 
static struct {
119 
  char *name;
120 
  char *string;
121 
  } or1k_signals [NUM_OR1K_SIGNALS + 1] =
122 
{
123 
  {"RSTE", "Reset Exception"},
124 
  {"DFPE", "Data Page Fault Exception"},
125 
  {"IFPE", "Instruction Page Fault Exception"},
126 
  {"LPINTE", "Low Priority Interrupt Exception"},
127 
  {"AE", "Alignment Exception"},
128 
  {"HPINTE", "High Priority Interrupt Exception"},
129 
  {"DME", "DTLB Miss Exception"},
130 
  {"IME", "ITLB Miss Exception"},
131 
  {"RE", "Range Exception"},
132 
  {"SCE", "SCE Exception"}, //!!!
133 
  {NULL, NULL}
134 
};
135 
 
136 104 markom 
/* *INDENT-ON* */
137 
 
138 
/* The list of available "set or1k " and "show or1k " commands */
139 
static struct cmd_list_element *setor1kcmdlist = NULL;
140 
static struct cmd_list_element *showor1kcmdlist = NULL;
141 
 
142 
/* List of all saved register addresses, produced by skip_prologue.
143 
   Relative address to sp, not used if 0.  */
144 
static int or1k_saved_reg_addr[NUM_REGS];
145 
 
146 
 
147 
/* Converts regno to sprno.  or1k debug unit has GPRs mapped to SPRs,
148 
   which are not compact, so we are mapping them for GDB.  */
149 
int
150 
or1k_regnum_to_sprnum (int regno)
151 
{
152 113 markom 
  if (regno < MAX_GPR_REGS)
153 115 markom 
    return SPR_REG(SPR_SYSTEM_GROUP, regno + CURRENT_CID * MAX_GPR_REGS + SPR_GPR_START);
154 104 markom 
  if (regno < MAX_GPR_REGS + MAX_VF_REGS)
155 113 markom 
    return SPR_REG(SPR_SYSTEM_GROUP, regno - MAX_GPR_REGS
156 115 markom 
                   + CURRENT_CID * MAX_GPR_REGS + SPR_VFPR_START);
157 113 markom 
  if (regno == PS_REGNUM)
158 
    return SR_SPRNUM;
159 104 markom 
  if (regno == PC_REGNUM)
160 
    return PC_SPRNUM;
161 
  if (regno == CCR_REGNUM)
162 113 markom 
    return CCR_SPRNUM(CURRENT_CID);
163 104 markom 
  error ("Invalid register number!");
164 
}
165 
 
166 
/* Builds and returns register name.  */
167 
 
168 
static char tmp_name[16];
169 
static char *
170 113 markom 
or1k_spr_register_name (i)
171 104 markom 
     int i;
172 
{
173 
  int group = i >> SPR_GROUP_SIZE_BITS;
174 
  int index = i & (SPR_GROUP_SIZE - 1);
175 
  switch (group)
176 
    {
177 
      /* Names covered in or1k_reg_names.  */
178 
    case 0:
179 115 markom 
      /* Generate upper names.  */
180 
      if (index >= SPR_GPR_START)
181 
        {
182 
          if (index < SPR_VFPR_START)
183 
            sprintf (tmp_name, "GPR%i", index - SPR_GPR_START);
184 
          else
185 
            sprintf (tmp_name, "VFR%i", index - SPR_VFPR_START);
186 
          return (char *)&tmp_name;
187 
        }
188 113 markom 
    case 3:
189 
    case 4:
190 
    case 5:
191 104 markom 
    case 6:
192 113 markom 
    case 7:
193 
    case 8:
194 
    case 9:
195 
    case 10:
196 104 markom 
      {
197 
        int group_start = 0;
198 
        for (i = 0; i < group; i++)
199 
          group_start += or1k_group_name_sizes[i];
200 
 
201 
        if (index >= or1k_group_name_sizes[group])
202 
          {
203 
            sprintf (tmp_name, "SPR%i_%i", group, index);
204 
            return (char *)&tmp_name;
205 
          }
206 
        else
207 115 markom 
          return or1k_reg_names[group_start + index - or1k_group_name_start[group]];
208 
      }
209 113 markom 
      /* Build names for DMMU group.  */
210 104 markom 
    case 1:
211 115 markom 
    case 2:
212 
      strcpy (tmp_name, (group == 1)?"D":"I");
213 104 markom 
      switch (index)
214 
        {
215 115 markom 
        case 16:
216 
          return strcat (tmp_name, "MMUCR");
217 
        case 17:
218 
          return strcat (tmp_name, "MMUPR");
219 
        case 18:
220 
          return strcat (tmp_name, "TLBEIR");
221 
        case 24:
222 
          return strcat (tmp_name, "ATBMR0");
223 
        case 25:
224 
          return strcat (tmp_name, "ATBMR1");
225 
        case 26:
226 
          return strcat (tmp_name, "ATBMR2");
227 
        case 27:
228 
          return strcat (tmp_name, "ATBMR3");
229 
        case 28:
230 
          return strcat (tmp_name, "ATBTR0");
231 
        case 29:
232 
          return strcat (tmp_name, "ATBTR0");
233 
        case 30:
234 
          return strcat (tmp_name, "ATBTR0");
235 
        case 31:
236 
          return strcat (tmp_name, "ATBTR0");
237 104 markom 
        default:
238 115 markom 
          if (index >= 1024) {
239 
            index -= 1024;
240 
            sprintf (tmp_name, "%sTLBW%iMR%i", (group == 1)?"D":"I", index / 128, index % 128);
241 
            return (char *)&tmp_name;
242 
          }
243 
          sprintf (tmp_name, "SPR%i_%i", group, index);
244 104 markom 
          return (char *)&tmp_name;
245 
      }
246 
    default:
247 
      sprintf (tmp_name, "SPR%i_%i", group, index);
248 
      return (char *)&tmp_name;
249 
    }
250 
}
251 
 
252 
/* Get register index in group from name.  Negative if no match.  */
253 
 
254 
static int
255 
or1k_regno_from_name (group, name)
256 
     int group;
257 
     char *name;
258 
{
259 
  int i;
260 
  if (toupper(name[0]) == 'S' && toupper(name[1]) == 'P' && toupper(name[2]) == 'R')
261 
    {
262 
      char *ptr_c;
263 
      name += 3;
264 
      i = (int) strtoul (name, &ptr_c, 10);
265 
      if (*ptr_c != '_' || i != group)
266 
        return -1;
267 
      ptr_c++;
268 
      i = (int) strtoul (name, &ptr_c, 10);
269 
      if (*ptr_c)
270 
        return -1;
271 
      else return i;
272 
    }
273 
  for (i = 0; i < or1k_spr_valid_aliases[group]; i++)
274 
    {
275 
      char *s;
276 113 markom 
      s = or1k_spr_register_name (SPR_REG(group, i));
277 104 markom 
      if (strcasecmp (name, s) == 0)
278 
        return i;
279 
    }
280 
  return -1;
281 
}
282 
 
283 
/* Resturs gdb register name.  */
284 
char *
285 
or1k_register_name (regno)
286 
     int regno;
287 
{
288 113 markom 
  return or1k_gdb_reg_names[regno];
289 104 markom 
}
290 
 
291 113 markom 
static int
292 
do_vf_register (regnum)
293 
     int regnum;
294 
{                               /* do values for FP (float) regs */
295 
  char *raw_buffer;
296 
  double doub, flt;             /* doubles extracted from raw hex data */
297 
  int inv1, inv3, byte;
298 
 
299 
  raw_buffer = (char *) alloca (OR1K_VF_REGSIZE);
300 
 
301 
  /* Get the data in raw format.  */
302 
  if (read_relative_register_raw_bytes (regnum, raw_buffer))
303 
    error ("can't read register %d (%s)", regnum, REGISTER_NAME (regnum));
304 
 
305 
  flt = unpack_double (builtin_type_float, raw_buffer, &inv1);
306 
  doub = unpack_double (builtin_type_double, raw_buffer, &inv3);
307 
 
308 116 markom 
  if (inv1)
309 
    printf_filtered (" %-5s flt: <invalid float>", REGISTER_NAME (regnum));
310 
  else
311 
    printf_filtered (" %-5s flt:%-17.9g", REGISTER_NAME (regnum), flt);
312 113 markom 
  printf_filtered (inv3 ? " dbl: <invalid double> " :
313 
                   " dbl: %-24.17g ", doub);
314 
 
315 
  /* pad small registers */
316 
  for (byte = 0; byte < (OR1K_GPR_REGSIZE - REGISTER_VIRTUAL_SIZE (regnum)); byte++)
317 
    printf_filtered ("  ");
318 
  /* Now print the register value in hex, endian order. */
319 
  if (TARGET_BYTE_ORDER == BIG_ENDIAN)
320 
    for (byte = REGISTER_RAW_SIZE (regnum) - REGISTER_VIRTUAL_SIZE (regnum);
321 
         byte < REGISTER_RAW_SIZE (regnum);
322 
         byte++)
323 
      printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
324 
  else
325 
    for (byte = REGISTER_VIRTUAL_SIZE (regnum) - 1;
326 
         byte >= 0;
327 
         byte--)
328 
      printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
329 
  printf_filtered ("\n");
330 
 
331 
  regnum++;
332 
  return regnum;
333 
}
334 
 
335 
/* Print a row's worth of GP (int) registers, with name labels above */
336 
 
337 
static int
338 
do_gp_register_row (regnum)
339 
     int regnum;
340 
{
341 
  /* do values for GP (int) regs */
342 
  char raw_buffer[MAX_REGISTER_RAW_SIZE];
343 
  int ncols = (OR1K_64BIT_IMPLEMENTATION ? 4 : 8);      /* display cols per row */
344 
  int col, byte;
345 
  int start_regnum = regnum;
346 
  int numregs = NUM_REGS;
347 
 
348 
 
349 
  /* For GP registers, we print a separate row of names above the vals */
350 
  printf_filtered ("     ");
351 
  for (col = 0; col < ncols && regnum < numregs; regnum++)
352 
    {
353 
      if (*REGISTER_NAME (regnum) == '\0')
354 
        continue;               /* unused register */
355 
      if (OR1K_IS_VF(regnum))
356 
        break;                  /* end the row: reached VF register */
357 
      printf_filtered (OR1K_64BIT_IMPLEMENTATION ? "%17s" : "%9s",
358 
                       REGISTER_NAME (regnum));
359 
      col++;
360 
    }
361 
  printf_filtered ("\n      ");
362 
 
363 
  regnum = start_regnum;        /* go back to start of row */
364 
 
365 
  /* now print the values in hex, 4 or 8 to the row */
366 
  for (col = 0; col < ncols && regnum < numregs; regnum++)
367 
    {
368 
      if (*REGISTER_NAME (regnum) == '\0')
369 
        continue;               /* unused register */
370 
      if (OR1K_IS_VF(regnum))
371 
        break;                  /* end row: reached VF register */
372 
      /* OK: get the data in raw format.  */
373 
      if (read_relative_register_raw_bytes (regnum, raw_buffer))
374 
        error ("can't read register %d (%s)", regnum, REGISTER_NAME (regnum));
375 
      /* pad small registers */
376 
      for (byte = 0; byte < (OR1K_GPR_REGSIZE - REGISTER_VIRTUAL_SIZE (regnum)); byte++)
377 
        printf_filtered ("  ");
378 
      /* Now print the register value in hex, endian order. */
379 
      if (TARGET_BYTE_ORDER == BIG_ENDIAN)
380 
        for (byte = REGISTER_RAW_SIZE (regnum) - REGISTER_VIRTUAL_SIZE (regnum);
381 
             byte < REGISTER_RAW_SIZE (regnum);
382 
             byte++)
383 
          printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
384 
      else
385 
        for (byte = REGISTER_VIRTUAL_SIZE (regnum) - 1;
386 
             byte >= 0;
387 
             byte--)
388 
          printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
389 
      printf_filtered (" ");
390 
      col++;
391 
    }
392 
  if (col > 0)                   /* ie. if we actually printed anything... */
393 
    printf_filtered ("\n");
394 
 
395 
  return regnum;
396 
}
397 
 
398 
/* Replacement for generic do_registers_info.
399 
   Print regs in pretty columns.  */
400 
static void
401 
print_register (regnum, all)
402 
     int regnum, all;
403 
{
404 
  int offset;
405 
  char raw_buffer[MAX_REGISTER_RAW_SIZE];
406 
 
407 
  /* Get the data in raw format.  */
408 
  if (read_relative_register_raw_bytes (regnum, raw_buffer))
409 
    {
410 
      printf_filtered ("%s: [Invalid]", REGISTER_NAME (regnum));
411 
      return;
412 
    }
413 
 
414 
  /* If virtual format is floating, print it that way.  */
415 
  if (OR1K_IS_VF (regnum))
416 
    do_vf_register (regnum);
417 
  else
418 
    {
419 
      int byte;
420 
      printf_filtered ("%-16s\t", REGISTER_NAME (regnum));
421 
 
422 
      /* pad small registers */
423 
      for (byte = 0; byte < (OR1K_GPR_REGSIZE - REGISTER_VIRTUAL_SIZE (regnum)); byte++)
424 
        printf_filtered ("  ");
425 
      /* Now print the register value in hex, endian order. */
426 
      if (TARGET_BYTE_ORDER == BIG_ENDIAN)
427 
        for (byte = REGISTER_RAW_SIZE (regnum) - REGISTER_VIRTUAL_SIZE (regnum);
428 
             byte < REGISTER_RAW_SIZE (regnum);
429 
             byte++)
430 
          printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
431 
      else
432 
        for (byte = REGISTER_VIRTUAL_SIZE (regnum) - 1;
433 
             byte >= 0;
434 
             byte--)
435 
          printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
436 
      printf_filtered (" ");
437 
    }
438 
}
439 
 
440 
/* DO_REGISTERS_INFO: called by "info register" command */
441 
 
442 
void
443 
or1k_do_registers_info (regnum, fpregs)
444 
     int regnum;
445 
     int fpregs;
446 
{
447 
  if (fpregs && !or1k_implementation.vf_present)
448 
    {
449 
      warning ("VF register set not present in this implementation.");
450 
      fpregs = 0;
451 
    }
452 
  if (regnum != -1)             /* do one specified register */
453 
    {
454 
      if (*(REGISTER_NAME (regnum)) == '\0')
455 
        error ("Not a valid register for the current processor type");
456 
 
457 
      print_register (regnum, 0);
458 
      printf_filtered ("\n");
459 
    }
460 
  else
461 
    /* do all (or most) registers */
462 
    {
463 
      regnum = 0;
464 
      while (regnum < NUM_REGS)
465 
        {
466 
          if (OR1K_IS_VF (regnum))
467 
            if (fpregs)         /* true for "INFO ALL-REGISTERS" command */
468 
              regnum = do_vf_register (regnum); /* FP regs */
469 
            else
470 
              regnum++;         /* skip floating point regs */
471 
          else
472 
            regnum = do_gp_register_row (regnum);       /* GP (int) regs */
473 
        }
474 
    }
475 
}
476 
 
477 104 markom 
/* Given the address at which to insert a breakpoint (BP_ADDR),
478 
   what will that breakpoint be?
479 
 
480 
   For or1k, we have a breakpoint instruction. Since all or1k
481 
   instructions are 32 bits, this is all we need, regardless of
482 
   address. K is not used.  */
483 
 
484 
unsigned char *
485 
or1k_breakpoint_from_pc (bp_addr, bp_size)
486 
     CORE_ADDR * bp_addr;
487 
     int *bp_size;
488 
{
489 113 markom 
  static char breakpoint[] = BRK_INSTR_STRUCT;
490 104 markom 
  *bp_size = OR1K_INSTLEN;
491 
  return breakpoint;
492 
}
493 
 
494 113 markom 
/* Return the string for a signal.  Replacement for target_signal_to_string (sig).  */
495 
char
496 
*or1k_signal_to_string (sig)
497 
     enum target_signal sig;
498 
{
499 
  if ((sig >= TARGET_SIGNAL_FIRST) && (sig <= TARGET_SIGNAL_LAST))
500 
    return or1k_signals[sig].string;
501 
  else
502 
    if (sig <= TARGET_SIGNAL_LAST + NUM_OR1K_SIGNALS)
503 
      return or1k_signals[sig - TARGET_SIGNAL_LAST].string;
504 
    else
505 
      return 0/* signals[TARGET_SIGNAL_UNKNOWN].string*/;
506 
}
507 
 
508 
/* Return the name for a signal.  */
509 
char *
510 
or1k_signal_to_name (sig)
511 
     enum target_signal sig;
512 
{
513 
  if (sig >= TARGET_SIGNAL_LAST)
514 
    if (sig <= TARGET_SIGNAL_LAST + NUM_OR1K_SIGNALS)
515 
      return or1k_signals[sig - TARGET_SIGNAL_LAST].name;
516 
    else
517 
    /* I think the code which prints this will always print it along with
518 
       the string, so no need to be verbose.  */
519 
      return "?";
520 
  if (sig == TARGET_SIGNAL_UNKNOWN)
521 
    return "?";
522 
  return 0/*!!!signals[sig].name*/;
523 
}
524 
 
525 
/* Given a name, return its signal.  */
526 
enum target_signal
527 
or1k_signal_from_name (name)
528 
     char *name;
529 
{
530 
  enum target_signal sig;
531 
 
532 
  /* It's possible we also should allow "SIGCLD" as well as "SIGCHLD"
533 
     for TARGET_SIGNAL_SIGCHLD.  SIGIOT, on the other hand, is more
534 
     questionable; seems like by now people should call it SIGABRT
535 
     instead.  */
536 
 
537 
  /* This ugly cast brought to you by the native VAX compiler.  */
538 
  for (sig = TARGET_SIGNAL_FIRST;
539 
       or1k_signal_to_name (sig) != NULL;
540 
       sig = (enum target_signal) ((int) sig + 1))
541 
    if (STREQ (name, or1k_signal_to_name (sig)))
542 
      return sig;
543 
  return TARGET_SIGNAL_UNKNOWN;
544 
}
545 
 
546 104 markom 
/* Given a return value in `regbuf' with a type `valtype', extract and
547 
   copy its value into `valbuf'. */
548 
void
549 
or1k_extract_return_value (valtype, regbuf, valbuf)
550 
     struct type *valtype;
551 
     char regbuf[REGISTER_BYTES];
552 
     char *valbuf;
553 
{
554 
  if (TYPE_CODE_FLT == TYPE_CODE (valtype))
555 
    memcpy (valbuf, &regbuf[REGISTER_BYTE (VFRV_REGNUM)], TYPE_LENGTH (valtype));
556 
  else
557 
    memcpy (valbuf, &regbuf[REGISTER_BYTE (RV_REGNUM)], TYPE_LENGTH (valtype));
558 
}
559 
 
560 
/* The or1k cc defines the following
561 
   prologue:
562 
00000000 <_proc1>:
563 
   0:   d7 e1 17 e4     l.sw 0xffffffe4(r1),r2
564 
   4:   9c 41 00 00     l.addi r2,r1,0x0
565 
   8:   9c 21 ff e8     l.addi r1,r1,0xffffffe8
566 
   c:   d7 e2 1f f8     l.sw 0xfffffff8(r2),r3
567 
  10:   d7 e2 27 f4     l.sw 0xfffffff4(r2),r4
568 
  14:   84 82 ff f8     l.lwz r4,0xfffffff8(r2)
569 
  18:   9d 24 00 00     l.addi r9,r4,0x0
570 
  1c:   00 00 00 02     l.j 0x2
571 
  20:   15 00 00 00     l.nop
572 
 
573 
00000024 <_L2>:
574 
  24:   84 41 ff fc     l.lwz r2,0xfffffffc(r1)
575 
  28:   48 00 58 00     l.jalr r11
576 
  2c:   9c 21 00 18     l.addi r1,r1,0x18 */
577 
 
578 
CORE_ADDR
579 
or1k_skip_prologue (CORE_ADDR pc)
580 
{
581 
  unsigned long inst;
582 
  CORE_ADDR skip_pc;
583 
  CORE_ADDR func_addr, func_end;
584 
  struct symtab_and_line sal;
585 
  int i;
586 
  int offset = 0;
587 
 
588 
  for (i = 0; i < MAX_GPR_REGS; i++)
589 
    or1k_saved_reg_addr[i] = -1;
590 
 
591 
  /* Is there a prologue?  */
592 
  inst = or1k_fetch_instruction (pc);
593 
  if (inst & 0xfc1ff800 != 0xd4011000) return pc; /* l.sw I(r1),r2 */
594 
  or1k_saved_reg_addr[2] = offset++;
595 
  inst = or1k_fetch_instruction (pc + OR1K_INSTLEN);
596 
  if (inst & 0xFFFF0000 != 0x9c410000) return pc; /* l.addi r2,r1,I */
597 
  pc += 2 * OR1K_INSTLEN;
598 
  inst = or1k_fetch_instruction (pc);
599 
  if (inst & 0xFFFF0000 != 0x9c210000) return pc; /* l.addi r1,r1,I */
600 
  pc += OR1K_INSTLEN;
601 
 
602 
  /* Skip stored registers.  */
603 
  inst = or1k_fetch_instruction (pc);
604 
  while (inst & 0xfc1ff800 != 0xd4020000)         /* l.sw 0x0(r2),rx */
605 
    {
606 
      /* get saved reg. */
607 
      or1k_saved_reg_addr[(inst >> 11) & 0x1f] = offset++;
608 
      pc += OR1K_INSTLEN;
609 
      inst = or1k_fetch_instruction (pc);
610 
    }
611 
  return pc;
612 
}
613 
 
614 
/* Determines whether this function has frame.  */
615 
 
616 
int
617 
or1k_frameless_function_invocation (struct frame_info *fi)
618 
{
619 
  CORE_ADDR func_start, after_prologue;
620 
  int frameless;
621 
  func_start = (get_pc_function_start ((fi)->pc) + FUNCTION_START_OFFSET);
622 
  after_prologue = SKIP_PROLOGUE (func_start);
623 
 
624 
  /* If we don't skip pc, we don't have even shortest possible  prologue.  */
625 
  frameless = (after_prologue <= func_start);
626 
  return frameless;
627 
}
628 
 
629 
/* Given a GDB frame, determine the address of the calling function's frame.
630 
   This will be used to create a new GDB frame struct, and then
631 
   INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame. */
632 
 
633 
CORE_ADDR
634 
or1k_frame_chain (frame)
635 
     struct frame_info *frame;
636 
{
637 
  CORE_ADDR fp;
638 
  if (USE_GENERIC_DUMMY_FRAMES)
639 
    {
640 
      if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
641 
        return frame->frame;    /* dummy frame same as caller's frame */
642 
    }
643 
 
644 
  if (inside_entry_file (frame->pc) ||
645 
      frame->pc == entry_point_address ())
646 
    return 0;
647 
 
648 
  if (frame->signal_handler_caller)
649 
    fp = read_memory_integer (frame->frame, 4);
650 
  else if (frame->next != NULL
651 
           && frame->next->signal_handler_caller
652 
           && FRAMELESS_FUNCTION_INVOCATION (frame))
653 
    /* A frameless function interrupted by a signal did not change the
654 
       frame pointer.  */
655 
    fp = FRAME_FP (frame);
656 
  else
657 
    fp = read_memory_integer (frame->frame, 4);
658 
 
659 
  if (USE_GENERIC_DUMMY_FRAMES)
660 
    {
661 
      CORE_ADDR fpp, lr;
662 
 
663 
      lr = read_register (LR_REGNUM);
664 
      if (lr == entry_point_address ())
665 
        if (fp != 0 && (fpp = read_memory_integer (fp, 4)) != 0)
666 
          if (PC_IN_CALL_DUMMY (lr, fpp, fpp))
667 
            return fpp;
668 
    }
669 
 
670 
  return fp;
671 
}
672 
 
673 
/* The code to store, into a struct frame_saved_regs,
674 
   the addresses of the saved registers of frame described by FRAME_INFO.
675 
   This includes special registers such as pc and fp saved in special
676 
   ways in the stack frame.  sp is even more special:
677 
   the address we return for it IS the sp for the next frame.  */
678 
void
679 
or1k_init_saved_regs (struct frame_info *fi)
680 
{
681 
  CORE_ADDR frame_addr;
682 
  int i;
683 
  frame_saved_regs_zalloc (fi);
684 
 
685 
  /* Skip prologue sets or1k_saved_reg_addr[], we will use it later.  */
686 
  or1k_skip_prologue (get_pc_function_start ((fi)->pc) + FUNCTION_START_OFFSET);
687 
 
688 116 markom 
  for (i = 0; i < NUM_GPR_REGS + NUM_VF_REGS; i++)
689 104 markom 
    if (or1k_saved_reg_addr[i] >= 0)
690 
      fi->saved_regs[i] = fi->frame + or1k_saved_reg_addr[i];
691 
}
692 
 
693 
 
694 
static CORE_ADDR
695 
read_next_frame_reg (fi, regno)
696 
     struct frame_info *fi;
697 
     int regno;
698 
{
699 
  for (; fi; fi = fi->next)
700 
    {
701 
      /* We have to get the saved sp from the sigcontext
702 
         if it is a signal handler frame.  */
703 
      if (regno == SP_REGNUM && !fi->signal_handler_caller)
704 
        return fi->frame;
705 
      else
706 
        {
707 
          if (fi->saved_regs == NULL)
708 
            or1k_init_saved_regs (fi);
709 
          if (fi->saved_regs[regno])
710 
            return read_memory_integer (ADDR_BITS_REMOVE (fi->saved_regs[regno]), OR1K_GPR_REGSIZE);
711 
        }
712 
    }
713 
  return read_register (regno);
714 
}
715 
 
716 
/* Find the caller of this frame.  We do this by seeing if LR_REGNUM
717 
   is saved in the stack anywhere, otherwise we get it from the
718 
   registers.  */
719 
 
720 
CORE_ADDR
721 
or1k_frame_saved_pc (fi)
722 
     struct frame_info *fi;
723 
{
724 
  CORE_ADDR saved_pc;
725 
  /* We have to get the saved pc from the sigcontext
726 
     if it is a signal handler frame.  */
727 
  if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
728 
    saved_pc = read_memory_integer (fi->frame, OR1K_GPR_REGSIZE);
729 
  else
730 
    saved_pc = read_next_frame_reg (fi, PC_REGNUM);
731 
 
732 
  return ADDR_BITS_REMOVE (saved_pc);
733 
}
734 
 
735 
/* Discard from the stack the innermost frame, restoring all registers.  */
736 
 
737 
void
738 
or1k_pop_frame ()
739 
{
740 
  register int regnum;
741 
  struct frame_info *frame = get_current_frame ();
742 
  CORE_ADDR new_sp = FRAME_FP (frame);
743 
 
744 
  write_register (PC_REGNUM, FRAME_SAVED_PC (frame));
745 
  if (frame->saved_regs == NULL)
746 
    or1k_init_saved_regs (frame);
747 
  for (regnum = 0; regnum < NUM_REGS; regnum++)    {
748 
      if (regnum != SP_REGNUM && regnum != PC_REGNUM
749 
          && frame->saved_regs[regnum] >= 0)
750 
        write_register (regnum,
751 
                        read_memory_integer (frame->saved_regs[regnum],
752 
                                             OR1K_GPR_REGSIZE));
753 
    }
754 
  write_register (SP_REGNUM, new_sp);
755 
  flush_cached_frames ();
756 
}
757 
 
758 
CORE_ADDR
759 
or1k_push_arguments (nargs, args, sp, struct_return, struct_addr)
760 
     int nargs;
761 
     value_ptr *args;
762 
     CORE_ADDR sp;
763 
     int struct_return;
764 
     CORE_ADDR struct_addr;
765 
{
766 
  int argreg;
767 
  int float_argreg;
768 
  int argnum;
769 
  int len = 0;
770 
  int stack_offset = 0;
771 
 
772 
  /* Initialize the integer and float register pointers.  */
773 
  argreg = A0_REGNUM;
774 
  float_argreg = VFA0_REGNUM;
775 
 
776 
  /* The struct_return pointer occupies the RV value register.  */
777 
  if (struct_return)
778 
    write_register (RV_REGNUM, struct_addr);
779 
 
780 
  /* Now load as many as possible of the first arguments into
781 
     registers, and push the rest onto the stack.  Loop thru args
782 
     from first to last.  */
783 
  for (argnum = 0; argnum < nargs; argnum++)
784 
    {
785 
      char *val;
786 
      char valbuf[MAX_REGISTER_RAW_SIZE];
787 
      value_ptr arg = args[argnum];
788 
      struct type *arg_type = check_typedef (VALUE_TYPE (arg));
789 
      int len = TYPE_LENGTH (arg_type);
790 
      enum type_code typecode = TYPE_CODE (arg_type);
791 
 
792 
      /* The EABI passes structures that do not fit in a register by
793 
         reference. In all other cases, pass the structure by value.  */
794 
      if (len > OR1K_GPR_REGSIZE &&
795 
          (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION))
796 
        {
797 
          store_address (valbuf, OR1K_GPR_REGSIZE, VALUE_ADDRESS (arg));
798 
          typecode = TYPE_CODE_PTR;
799 
          len = OR1K_GPR_REGSIZE;
800 
          val = valbuf;
801 
        }
802 
      else
803 
        {
804 
          val = (char *) VALUE_CONTENTS (arg);
805 
 
806 
          if (typecode == TYPE_CODE_FLT
807 
              /* Doubles are not stored in regs on 32b target.  */
808 
              && len <= OR1K_VF_REGSIZE
809 
              && OR1K_VF_PRESENT)
810 
            {
811 
              if (float_argreg <= OR1K_LAST_FP_ARG_REGNUM)
812 
                {
813 
                  CORE_ADDR regval = extract_address (val, len);
814 
                  write_register (float_argreg++, regval);
815 
                }
816 
              else
817 
                {
818 
                  write_memory ((CORE_ADDR) sp, val, OR1K_VF_REGSIZE);
819 
                  sp -= OR1K_STACK_ALIGN;
820 
                }
821 
            }
822 
          else
823 
            {
824 
              if (argreg <= OR1K_LAST_ARG_REGNUM)
825 
                {
826 
                  CORE_ADDR regval = extract_address (val, len);
827 
                  write_register (argreg++, regval);
828 
                }
829 
              else
830 
                {
831 
                  write_memory ((CORE_ADDR) sp, val, OR1K_GPR_REGSIZE);
832 
                  sp -= OR1K_STACK_ALIGN;
833 
                }
834 
            }
835 
        }
836 
    }
837 
 
838 
  /* Return adjusted stack pointer.  */
839 
  return sp;
840 
}
841 
 
842 
/* Return nonzero when instruction has delay slot.  */
843 
static int
844 
is_delayed (insn)
845 
     unsigned long insn;
846 
{
847 
  int i;
848 
  for (i = 0; i < num_opcodes; ++i)
849 
    if ((or32_opcodes[i].flags & OR32_IF_DELAY)
850 
        && (or32_opcode_match (insn, or32_opcodes[i].encoding)))
851 
      break;
852 
  return (i < num_opcodes);
853 
}
854 
 
855 
int
856 
or1k_step_skips_delay (pc)
857 
     CORE_ADDR pc;
858 
{
859 
  char buf[OR1K_INSTLEN];
860 
 
861 
  if (target_read_memory (pc, buf, OR1K_INSTLEN) != 0)
862 
    /* If error reading memory, guess that it is not a delayed branch.  */
863 
    return 0;
864 
  return is_delayed ((unsigned long) extract_unsigned_integer (buf, OR1K_INSTLEN));
865 
}
866 
 
867 
CORE_ADDR
868 
or1k_push_return_address (pc, sp)
869 
     CORE_ADDR pc;
870 
     CORE_ADDR sp;
871 
{
872 
  /* Set the return address register to point to the entry
873 
     point of the program, where a breakpoint lies in wait.  */
874 
  write_register (LR_REGNUM, CALL_DUMMY_ADDRESS ());
875 
  return sp;
876 
}
877 
 
878 
/* Root of all "set or1k "/"show or1k " commands. This will eventually be
879 
   used for all OR1K-specific commands.  */
880 
 
881 
static void show_or1k_command PARAMS ((char *, int));
882 
static void
883 
show_or1k_command (args, from_tty)
884 
     char *args;
885 
     int from_tty;
886 
{
887 
  help_list (showor1kcmdlist, "show or1k ", all_commands, gdb_stdout);
888 
}
889 
 
890 
static void set_or1k_command PARAMS ((char *, int));
891 
static void
892 
set_or1k_command (args, from_tty)
893 
     char *args;
894 
     int from_tty;
895 
{
896 
  printf_unfiltered ("\"set or1k\" must be followed by an appropriate subcommand.\n");
897 
  help_list (setor1kcmdlist, "set or1k ", all_commands, gdb_stdout);
898 
}
899 
 
900 115 markom 
/* Parses args for spr name and puts result into group and index.  */
901 
 
902 104 markom 
static char *
903 
parse_spr_params (args, group, index)
904 
                  char *args;
905 
                  int *group, *index;
906 
{
907 
  *index = -1;
908 
  if (args)
909 
    {
910 
      int i;
911 
      char *ptr_c;
912 
      /* Check if group number was supplied.  */
913 
      ptr_c = args;
914 
      while (*ptr_c != ' ' && *ptr_c != 0)
915 
        ptr_c++;
916 
      *ptr_c = 0;
917 
 
918 
      *group = (int) strtoul (args, &ptr_c, 0);
919 
      if (*ptr_c != 0)
920 
        {
921 
          *group = OR1K_NUM_SPR_GROUPS;
922 
          /* check for group name */
923 
          for (i = 0; i < OR1K_NUM_SPR_GROUPS; i++)
924 
            if (strcasecmp (or1k_group_names[i], args) == 0)
925 
              {
926 
                *group = i;
927 
                break;
928 
              }
929 
          /* Invalid group => check all register names in all groups.  */
930 
          if (*group >= OR1K_NUM_SPR_GROUPS)
931 
            {
932 
              for (i = 0; i < OR1K_NUM_SPR_GROUPS; i++)
933 
                {
934 
                  int regno;
935 
                  regno = or1k_regno_from_name (i, args);
936 
                  if (regno >= 0)
937 
                    {
938 
                      *group = i;
939 
                      *index = regno;
940 
                    }
941 
                }
942 
            }
943 
        }
944 
      if (*group < 0 || *group >= OR1K_NUM_SPR_GROUPS)
945 
        error ("Invalid group or register.\n");
946 
 
947 
      if (*index < 0)
948 
        {
949 
          args += strlen(args) + 1;
950 
          ptr_c = args;
951 
          while (*ptr_c != ' ' && *ptr_c != 0)
952 
            ptr_c++;
953 
          *ptr_c = 0;
954 
          *index = (int) strtoul (args, &ptr_c, 0);
955 
          if (*ptr_c != 0)
956 
            *index = or1k_regno_from_name (*group, args);
957 115 markom 
          else *index = -1;
958 104 markom 
 
959 
          if (*index < 0)
960 
            {
961 115 markom 
              printf_filtered ("No register supplied. Valid registers are:\n");
962 104 markom 
              for (i = 0; i < or1k_spr_valid_aliases[*group]; i++)
963 115 markom 
                {
964 
                  char reg_name[16];
965 
                  char *gen_name = or1k_spr_register_name (SPR_REG(*group, i));
966 
                  sprintf (reg_name, "SPR%i_%i", *group, i);
967 
                  if (strcmp (reg_name, gen_name) != 0)
968 
                    printf_filtered ("%s\t", gen_name);
969 
                }
970 
              printf_filtered ("\n");
971 104 markom 
              return args + strlen(args) + 1;
972 
            }
973 
        }
974 
    }
975 
  else
976 
  /* No parameters - print groups */
977 
    {
978 
      int i;
979 115 markom 
      printf_filtered ("No parameter supplied. Valid groups are:\n");
980 104 markom 
      for (i = 0; i < OR1K_NUM_SPR_GROUPS; i++)
981 115 markom 
        printf_filtered ("%s\t", or1k_group_names[i]);
982 
      printf_filtered ("\nSingle register name or register name or number after the group can be also supplied.\n");
983 
      return args;
984 104 markom 
    }
985 
  return args + strlen(args) + 1;
986 
}
987 
 
988 
/* SPR register info.  */
989 
 
990 
void
991 116 markom 
info_spr_command (args, from_tty)
992 
     char *args;
993 
     int from_tty;
994 104 markom 
{
995 
  int group, index;
996 
  parse_spr_params (args, &group, &index);
997 
  if (index >= 0)
998 
    {
999 
      printf_unfiltered ("%s.%s (SPR%i_%i) set to %i(%X), was:%i(%X)\n", or1k_group_names[group],
1000 113 markom 
                         or1k_spr_register_name (SPR_REG(group, index)), group, index,
1001 
                         or1k_read_spr_reg (SPR_REG(group, index)));
1002 104 markom 
    }
1003 
}
1004 
 
1005 
/* Set SPR register.  */
1006 
 
1007 
void
1008 116 markom 
spr_command (args, from_tty)
1009 
     char *args;
1010 
     int from_tty;
1011 104 markom 
{
1012 
  int group, index;
1013 
  char *nargs = parse_spr_params (args, &group, &index);
1014 
  if (index >= 0)
1015 
    {
1016 
      unsigned long prev;
1017 
      unsigned long value;
1018 
      char *ptr_c;
1019 
 
1020 115 markom 
      /* Any arguments left?  */
1021 
      if (args + strlen(args) >= nargs)
1022 
        error ("Invalid register value.");
1023 
 
1024 113 markom 
      prev = or1k_read_spr_reg (SPR_REG(group, index));
1025 104 markom 
 
1026 
      ptr_c = nargs;
1027 
      while (*ptr_c != ' ' && *ptr_c != 0)
1028 
        ptr_c++;
1029 
      *ptr_c = 0;
1030 
      value = strtoul (nargs, &ptr_c, 0);
1031 
      if (*ptr_c != 0)
1032 
        error ("Invalid register value.");
1033 
      printf_unfiltered ("%s.%s (SPR%i_%i) set to %i(%X), was:%i(%X)\n", or1k_group_names[group],
1034 113 markom 
                         or1k_spr_register_name (SPR_REG(group, index)), group, index,
1035 104 markom 
                         value, value, prev, prev);
1036 
    }
1037 
}
1038 
 
1039 
/* Calls extended command on target.  */
1040 
 
1041 
void
1042 116 markom 
sim_command (args, from_tty)
1043 
     char *args;
1044 
     int from_tty;
1045 104 markom 
{
1046 
  or1k_sim_cmd (args, from_tty);
1047 
}
1048 
 
1049 116 markom 
int
1050 
or1k_parse_any (exp)
1051 
     union exp_element *exp;
1052 
{
1053 
  if (exp->opcode == BINOP_LOGICAL_AND)
1054 
    {
1055 
      //!!!
1056 
    }
1057 
}
1058 
 
1059 113 markom 
/* ARGSUSED */
1060 
/* accessflag:  hw_write:  watch write,
1061 
                hw_read:   watch read,
1062 
                hw_access: watch access (read or write) */
1063 
static void
1064 
hwatch_command (arg, from_tty)
1065 
     char *arg;
1066 
     int from_tty;
1067 
{
1068 
  struct expression *exp;
1069 
  int i;
1070 
  int nfree;
1071 
  /* Parse arguments.  */
1072 
  exp = parse_exp_1 (&arg, 0, 0);
1073 
 
1074 
  dump_prefix_expression (exp, gdb_stdout, "expr1");
1075 
 
1076 116 markom 
  if (or1k_parse_any (&exp->elts[0]))
1077 
    {
1078 
      //!!!
1079 
      printf_unfiltered ("Watchpoint successfully allocated.");
1080 
    }
1081 
  else
1082 
    printf_unfiltered ("Not enough resources to set specified watchpoint.");
1083 113 markom 
  /* Now we have to find out if given prefix expression matches
1084 
     our HW based support. It may take up to
1085 
     or1k_implementation.num_matchpoints - or1k_implementation.num_used_matchpoints. */
1086 
  nfree = or1k_implementation.num_matchpoints - or1k_implementation.num_used_matchpoints;
1087 
  //printf_unfiltered ("%s\n", exp->elts[1].internalvar->name);
1088 
  free (exp);
1089 
}
1090 
 
1091 104 markom 
void
1092 
_initialize_or1k_tdep ()
1093 
{
1094 
  struct cmd_list_element *c;
1095 
  /* Add root prefix command for all "set or1k"/"show or1k" commands */
1096 
  add_prefix_cmd ("or1k", no_class, set_or1k_command,
1097 
                  "Various OR1K specific commands.",
1098 
                  &setor1kcmdlist, "set or1k ", 0, &setlist);
1099 
 
1100 
  add_prefix_cmd ("or1k", no_class, show_or1k_command,
1101 
                  "Various OR1K specific commands.",
1102 
                  &showor1kcmdlist, "show or1k ", 0, &showlist);
1103 
 
1104 
  /* Commands to show information about the sprs.  */
1105 113 markom 
  add_info ("spr", info_spr_command, "Show information about the spr registers.");
1106 
  add_com ("hwatch", class_breakpoint, hwatch_command, "Set hardware watchpoint.");
1107 
  add_com ("spr", class_support, spr_command, "Set specified SPR register.");
1108 104 markom 
  add_com ("sim", class_obscure, sim_command,
1109 
           "Send a extended command to the simulator.");
1110 
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.