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 603

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

Line No. Rev Author Line
1 120 markom 
/* Target-dependent code for the or1k architecture, for GDB, the GNU Debugger.
2 
 
3 
   Copyright 1988-1999, Free Software Foundation, Inc.
4 
   Contributed by Alessandro Forin(af@cs.cmu.edu at CMU
5 
   and by Per Bothner(bothner@cs.wisc.edu) at U.Wisconsin.
6 
 
7 
   This file is part of GDB.
8 
 
9 
   This program is free software; you can redistribute it and/or modify
10 
   it under the terms of the GNU General Public License as published by
11 
   the Free Software Foundation; either version 2 of the License, or
12 
   (at your option) any later version.
13 
 
14 
   This program is distributed in the hope that it will be useful,
15 
   but WITHOUT ANY WARRANTY; without even the implied warranty of
16 
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 
   GNU General Public License for more details.
18 
 
19 
   You should have received a copy of the GNU General Public License
20 
   along with this program; if not, write to the Free Software
21 
   Foundation, Inc., 59 Temple Place - Suite 330,
22 
   Boston, MA 02111-1307, USA.  */
23 
 
24 
#include "demangle.h"
25 
#include "defs.h"
26 
#include "gdb_string.h"
27 
#include "frame.h"
28 
#include "inferior.h"
29 
#include "symtab.h"
30 
#include "value.h"
31 
#include "gdbcmd.h"
32 
#include "language.h"
33 
#include "gdbcore.h"
34 
#include "symfile.h"
35 
#include "objfiles.h"
36 
#include "gdbtypes.h"
37 
#include "target.h"
38 
 
39 
#include "opcode/or32.h"
40 
 
41 
/* *INDENT-OFF* */
42 
 
43 
/* Group reg name size.  See or1k_reg_names.  */
44 
int or1k_group_name_sizes[OR1K_NUM_SPR_GROUPS] = {
45 593 markom 
  80,   0,   0, 6, 4, 2,
46 372 markom 
  22, 16, 1, 3, 2, 8
47 
};
48 120 markom 
 
49 
int or1k_group_name_start[OR1K_NUM_SPR_GROUPS] = {
50 
  0,   0,   0, 253, 254, 256,
51 372 markom 
  0, 248,  16, 16,  255, 0
52 
};
53 120 markom 
 
54 
/* Generated reg names (max valid alias index).
55 
   See or1k_spr_reg_name.  */
56 
int or1k_spr_valid_aliases[OR1K_NUM_SPR_GROUPS] = {
57 
  2047+1, 2047+1, 2047+1, 258+1, 257+1, 257+1,
58 372 markom 
  78+1, 263+1, 16+1, 18+1, 256+1, 7+1
59 
};
60 120 markom 
 
61 
/* Register names.  */
62 
char *or1k_reg_names[] = {
63 
 
64 
  /* group 0 - general*/
65 
  "VR", "UPR", "CPUCFGR", "DMMUCFGR", "IMMUCFGR", "DCCFGR", "ICCFGR", "DCFGR",
66 
  "PCCFGR", "SPR0_9", "SPR0_10", "SPR0_11", "SPR0_12", "SPR0_13", "SPR0_14", "SPR0_15",
67 577 markom 
  "NPC", "SR", "PPC", "SPR0_19", "SPR0_20", "SPR0_21", "SPR0_22", "SPR0_23",
68 593 markom 
  "SPR0_24", "SPR0_25", "SPR0_26", "SPR0_27", "SPR0_28", "SPR0_29", "SPR0_30", "SPR0_31",
69 120 markom 
  "EPCR0", "EPCR1", "EPCR2", "EPCR3", "EPCR4", "EPCR5", "EPCR6", "EPCR7",
70 
  "EPCR8", "EPCR9", "EPCR10", "EPCR11", "EPCR12", "EPCR13", "EPCR14", "EPCR15",
71 
  "EEAR0","EEAR1", "EEAR2", "EEAR3", "EEAR4", "EEAR5", "EEAR6", "EEAR7",
72 
  "EEAR8", "EEAR9", "EEAR10", "EEAR11", "EEAR12", "EEAR13", "EEAR14", "EEAR15",
73 
  "ESR0", "ESR1", "ESR2", "ESR3", "ESR4", "ESR5", "ESR6", "ESR7",
74 
  "ESR8", "ESR9", "ESR10", "ESR11", "ESR12", "ESR13", "ESR14", "ESR15",
75 
 
76 
  /* gpr+vf registers generated */
77 
  /* group 1 - Data MMU - not listed, generated */
78 
  /* group 2 - Instruction MMU - not listed, generated */
79 
 
80 
  /* group 3 - Data cache */
81 593 markom 
  "DCCR", "DCBPR", "DCBFR", "DCBIR", "DCBWR", "DCBLR",
82 120 markom 
 
83 
  /* group 4 - Instruction cache */
84 593 markom 
  "ICCR", "ICBPR", "ICBIR", "ICBLR",
85 120 markom 
 
86 
  /* group 5 - MAC */
87 
  "MACLO", "MACHI",
88 
 
89 
  /* group 6 - debug */
90 
  "DVR0", "DVR1", "DVR2", "DVR3", "DVR4", "DVR5", "DVR6", "DVR7",
91 
  "DCR0", "DCR1", "DCR2", "DCR3", "DCR4", "DCR5", "DCR6", "DCR7",
92 362 markom 
  "DMR1", "DMR2", "DCWR0","DCWR1","DSR",  "DRR",
93 120 markom 
 
94 
  /* group 7 - performance counters unit */
95 
  "PCCM0", "PCMR1", "PCMR2", "PCMR3", "PCMR4", "PCMR5", "PCMR6", "PCMR7",
96 
  "PCCR0", "PCCR1", "PCCR2", "PCCR3", "PCCR4", "PCCR5", "PCCR6", "PCCR7",
97 
 
98 
  /* group 8 - power management */
99 
  "PMR",
100 
 
101 
  /* group 9 - PIC */
102 
  "PICMR", "PICPR",
103 
 
104 
  /* group 10 - tick timer */
105 
  "TTMR", "TTCR",
106 
 
107 
  /* group 11 - configuration */
108 
  "CPUCFGR", "DMMUCFGR", "IMMUCFGR", "DCCFGR", "ICCFGR", "SPR11_5", "DCFGR", "PCCFGR"
109 
};
110 
 
111 
static char *or1k_gdb_reg_names[] = {
112 
 
113 
  /* general purpose registers */
114 372 markom 
  "R0",  "R1",  "R2",  "R3",  "R4",  "R5",  "R6",  "R7",
115 
  "R8",  "R9",  "R10", "R11", "R12", "R13", "R14", "R15",
116 120 markom 
  "R16", "R17", "R18", "R19", "R20", "R21", "R22", "R23",
117 
  "R24", "R25", "R26", "R27", "R28", "R29", "R30", "R31",
118 
 
119 207 chris 
  /* Modified by CZ 12/09/01 */
120 120 markom 
  /* vector/floating point registers */
121 
  "VFA0",  "VFA1",  "VFA2",  "VFA3",  "VFA4",  "VFA5",  "VFRV ", "VFR7",
122 
  "VFR8",  "VFR9",  "VFR10", "VFR11", "VFR12", "VFR13", "VFR14", "VFR15",
123 
  "VFR16", "VFR17", "VFR18", "VFR19", "VFR20", "VFR21", "VFR22", "VFR23",
124 
  "VFR24", "VFR25", "VFR26", "VFR27", "VFR28", "VFR29", "VFR30", "VFR31",
125 207 chris 
  "PC",    "SR",    "EPCR", "ExPC", "ExEAR", "ExSR"
126 120 markom 
};
127 
 
128 
static char *or1k_group_names[] = {
129 372 markom 
  "SYS", "DMMU", "IMMU", "DCACHE", "ICACHE", "MAC", "DEBUG", "PERF",
130 
  "POWER", "PIC", "TIMER", "CONFIG"
131 120 markom 
};
132 
 
133 
/* Table of or1k signals.  */
134 
static struct
135 
  {
136 
  char *name;
137 
  char *string;
138 
  } or1k_signals [NUM_OR1K_SIGNALS + 1] =
139 
  {
140 
    {"RSTE", "Reset Exception"},
141 207 chris 
    {"BUSE", "Bus Error" },
142 120 markom 
    {"DFPE", "Data Page Fault Exception"},
143 
    {"IFPE", "Instruction Page Fault Exception"},
144 
    {"LPINTE", "Low Priority Interrupt Exception"},
145 
    {"AE", "Alignment Exception"},
146 207 chris 
    {"ILINSE" "Illegal Instruction" },
147 120 markom 
    {"HPINTE", "High Priority Interrupt Exception"},
148 
    {"DME", "DTLB Miss Exception"},
149 
    {"IME", "ITLB Miss Exception"},
150 
    {"RE", "Range Exception"},
151 
    {"SCE", "SCE Exception"},
152 207 chris 
    {"BRKPTE", "Breakpoint Exception"},
153 120 markom 
    {NULL, NULL}
154 
  };
155 
 
156 
const char *compare_to_names[NUM_CT_NAMES] =
157 
  {
158 
    "DISABLED", "FETCH", "LEA", "SEA", "LDATA", "SDATA", "AEA", "ADATA"
159 
  };
160 
 
161 
const char *or1k_record_names[MAX_RECORD_NAMES] =
162 
  {
163 
    "PC", "LSEA", "LDATA", "SDATA", "READSPR", "WRITESPR", "INSTR"
164 
  };
165 
 
166 
const char *or1k_is_names[MAX_IS_NAMES] =
167 
  {
168 
    "IF_NONE", "IF_NORMAL", "IF_BRANCH", "IF_DELAY"
169 
  };
170 
 
171 
const char *or1k_ls_names[MAX_LS_NAMES] =
172 
  {
173 
    "LS_NONE", " ", "LBZ", "LBS", "LHZ", "LHS", "LWZ", "LWS",
174 
    " ", " ", "SB", " ", "SH", " ", "SW", " "
175 
  };
176 
 
177 
/* *INDENT-ON* */
178 
 
179 
/* The list of available "set or1k " and "show or1k " commands */
180 
static struct cmd_list_element *htrace_cmdlist = NULL;
181 
static struct cmd_list_element *htrace_mode_cmdlist = NULL;
182 
 
183 
/* List of all saved register addresses, produced by skip_prologue.
184 
   Relative address to sp, not used if 0.  */
185 
static int or1k_saved_reg_addr[NUM_REGS];
186 
 
187 
struct htrace_struct or1k_htrace;
188 
struct hwatch_struct or1k_hwatch[MAX_HW_WATCHES];
189 
int num_hw_watches = 0;
190 
 
191 
/* Trace data.  */
192 
char trace_filename[TRACE_FILENAME_SIZE] = "trace.dat";
193 
 
194 
/* Size of trace file in records.  */
195 
int trace_size = 0;
196 
 
197 
/* Previous values for buffer display.  */
198 
static int prev_length = 10;
199 
static int prev_from = 0;
200 
 
201 
/* Converts regno to sprno.  or1k debug unit has GPRs mapped to SPRs,
202 
   which are not compact, so we are mapping them for GDB.  */
203 207 chris 
/* Rewritten by CZ 12/09/01 */
204 120 markom 
int
205 
or1k_regnum_to_sprnum (int regno)
206 
{
207 207 chris 
  if(regno < MAX_GPR_REGS)
208 120 markom 
    return SPR_REG(SPR_SYSTEM_GROUP, regno + CURRENT_CID * MAX_GPR_REGS + SPR_GPR_START);
209 207 chris 
 
210 120 markom 
  if (regno < MAX_GPR_REGS + MAX_VF_REGS)
211 
    return SPR_REG(SPR_SYSTEM_GROUP, regno - MAX_GPR_REGS
212 
                   + CURRENT_CID * MAX_GPR_REGS + SPR_VFPR_START);
213 207 chris 
 
214 
  switch(regno)
215 
    {
216 
    case PS_REGNUM:         return SR_SPRNUM;
217 
    case PC_REGNUM:         return PC_SPRNUM;
218 362 markom 
    /*case CCR_REGNUM:        return CCR_SPRNUM(CURRENT_CID);*/
219 
    case EPCR_REGNUM:        return EPCR_SPRNUM(CURRENT_CID);
220 
    /*case EAR_REGNUM:        return EAR_SPRNUM(CURRENT_CID);
221 
    case ESR_REGNUM:        return ESR_SPRNUM(CURRENT_CID);*/
222 207 chris 
    default:
223 
      error("Invalid register number!");
224 
      break;
225 
    }
226 
 
227 
  return 0;
228 120 markom 
}
229 
 
230 
/* Builds and returns register name.  */
231 
 
232 
static char tmp_name[16];
233 
static char *
234 
or1k_spr_register_name (i)
235 
     int i;
236 
{
237 
  int group = i >> SPR_GROUP_SIZE_BITS;
238 
  int index = i & (SPR_GROUP_SIZE - 1);
239 
  switch (group)
240 
    {
241 
      /* Names covered in or1k_reg_names.  */
242 
    case 0:
243 
 
244 
      /* Generate upper names.  */
245 
      if (index >= SPR_GPR_START)
246 
        {
247 
          if (index < SPR_VFPR_START)
248 
            sprintf (tmp_name, "GPR%i", index - SPR_GPR_START);
249 
          else
250 
            sprintf (tmp_name, "VFR%i", index - SPR_VFPR_START);
251 
          return (char *)&tmp_name;
252 
        }
253 
    case 3:
254 
    case 4:
255 
    case 5:
256 
    case 6:
257 
    case 7:
258 
    case 8:
259 
    case 9:
260 
    case 10:
261 
      {
262 
        int group_start = 0;
263 
        for (i = 0; i < group; i++)
264 
          group_start += or1k_group_name_sizes[i];
265 
 
266 362 markom 
        index -= or1k_group_name_start[group];
267 120 markom 
        if (index >= or1k_group_name_sizes[group])
268 
          {
269 
            sprintf (tmp_name, "SPR%i_%i", group, index);
270 
            return (char *)&tmp_name;
271 
          }
272 
        else
273 362 markom 
          return or1k_reg_names[group_start + index];
274 120 markom 
      }
275 
 
276 
      /* Build names for DMMU group.  */
277 
    case 1:
278 
    case 2:
279 
      strcpy (tmp_name, (group == 1)?"D":"I");
280 
      switch (index)
281 
        {
282 
        case 16:
283 
          return strcat (tmp_name, "MMUCR");
284 
        case 17:
285 
          return strcat (tmp_name, "MMUPR");
286 
        case 18:
287 
          return strcat (tmp_name, "TLBEIR");
288 
        case 24:
289 
          return strcat (tmp_name, "ATBMR0");
290 
        case 25:
291 
          return strcat (tmp_name, "ATBMR1");
292 
        case 26:
293 
          return strcat (tmp_name, "ATBMR2");
294 
        case 27:
295 
          return strcat (tmp_name, "ATBMR3");
296 
        case 28:
297 
          return strcat (tmp_name, "ATBTR0");
298 
        case 29:
299 
          return strcat (tmp_name, "ATBTR0");
300 
        case 30:
301 
          return strcat (tmp_name, "ATBTR0");
302 
        case 31:
303 
          return strcat (tmp_name, "ATBTR0");
304 
        default:
305 
          if (index >= 1024) {
306 
            index -= 1024;
307 
            sprintf (tmp_name, "%sTLBW%iMR%i", (group == 1)?"D":"I", index / 128, index % 128);
308 
            return (char *)&tmp_name;
309 
          }
310 
          sprintf (tmp_name, "SPR%i_%i", group, index);
311 
          return (char *)&tmp_name;
312 
      }
313 
    default:
314 
      sprintf (tmp_name, "SPR%i_%i", group, index);
315 
      return (char *)&tmp_name;
316 
    }
317 
}
318 
 
319 
/* Get register index in group from name.  Negative if no match.  */
320 
 
321 
static int
322 
or1k_regno_from_name (group, name)
323 
     int group;
324 
     char *name;
325 
{
326 
  int i;
327 
  if (toupper(name[0]) == 'S' && toupper(name[1]) == 'P' && toupper(name[2]) == 'R')
328 
    {
329 
      char *ptr_c;
330 
      name += 3;
331 
      i = (int) strtoul (name, &ptr_c, 10);
332 
      if (*ptr_c != '_' || i != group)
333 
        return -1;
334 
      ptr_c++;
335 
      i = (int) strtoul (name, &ptr_c, 10);
336 
      if (*ptr_c)
337 
        return -1;
338 
      else return i;
339 
    }
340 362 markom 
  for (i = or1k_group_name_start[group]; i < or1k_spr_valid_aliases[group]; i++)
341 120 markom 
    {
342 
      char *s;
343 
      s = or1k_spr_register_name (SPR_REG(group, i));
344 
      if (strcasecmp (name, s) == 0)
345 
        return i;
346 
    }
347 
  return -1;
348 
}
349 
 
350 
/* Returns gdb register name.  */
351 
 
352 
char *
353 
or1k_register_name (regno)
354 
     int regno;
355 
{
356 
  return or1k_gdb_reg_names[regno];
357 
}
358 
 
359 
/* Utility function to display vf regs.  */
360 
 
361 
static int
362 
do_vf_register (regnum)
363 
     int regnum;
364 
{
365 
  /* do values for FP (float) regs */
366 
  char *raw_buffer;
367 
 
368 
   /* doubles extracted from raw hex data */
369 
  double doub, flt;
370 
  int inv1, inv3, byte;
371 
 
372 
  raw_buffer = (char *) alloca (OR1K_VF_REGSIZE);
373 
 
374 
  /* Get the data in raw format.  */
375 
  if (read_relative_register_raw_bytes (regnum, raw_buffer))
376 
    error ("can't read register %d (%s)", regnum, REGISTER_NAME (regnum));
377 
 
378 
  flt = unpack_double (builtin_type_float, raw_buffer, &inv1);
379 
  doub = unpack_double (builtin_type_double, raw_buffer, &inv3);
380 
 
381 
  if (inv1)
382 
    printf_filtered (" %-5s flt: <invalid float>", REGISTER_NAME (regnum));
383 
  else
384 
    printf_filtered (" %-5s flt:%-17.9g", REGISTER_NAME (regnum), flt);
385 
  printf_filtered (inv3 ? " dbl: <invalid double> " :
386 
                   " dbl: %-24.17g ", doub);
387 
 
388 
  /* pad small registers */
389 
  for (byte = 0; byte < (OR1K_GPR_REGSIZE - REGISTER_VIRTUAL_SIZE (regnum)); byte++)
390 
    printf_filtered ("  ");
391 
 
392 
  /* Now print the register value in hex, endian order. */
393 
  if (TARGET_BYTE_ORDER == BIG_ENDIAN)
394 
    for (byte = REGISTER_RAW_SIZE (regnum) - REGISTER_VIRTUAL_SIZE (regnum);
395 
         byte < REGISTER_RAW_SIZE (regnum);
396 
         byte++)
397 
      printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
398 
  else
399 
    for (byte = REGISTER_VIRTUAL_SIZE (regnum) - 1;
400 
         byte >= 0;
401 
         byte--)
402 
      printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
403 
  printf_filtered ("\n");
404 
 
405 
  regnum++;
406 
  return regnum;
407 
}
408 
 
409 
/* Print a row's worth of GP (int) registers, with name labels above */
410 
 
411 
static int
412 
do_gp_register_row (regnum)
413 
     int regnum;
414 
{
415 
  /* do values for GP (int) regs */
416 
  char raw_buffer[MAX_REGISTER_RAW_SIZE];
417 
 
418 
  /* display cols per row */
419 
  int ncols = (OR1K_64BIT_IMPLEMENTATION ? 4 : 8);
420 
  int col, byte;
421 
  int start_regnum = regnum;
422 
  int numregs = NUM_REGS;
423 
 
424 
  /* For GP registers, we print a separate row of names above the vals */
425 
  printf_filtered ("     ");
426 
  for (col = 0; col < ncols && regnum < numregs; regnum++)
427 
    {
428 
      if (*REGISTER_NAME (regnum) == '\0')
429 
        continue;               /* unused register */
430 
      if (OR1K_IS_VF(regnum))
431 
        break;                  /* end the row: reached VF register */
432 
      printf_filtered (OR1K_64BIT_IMPLEMENTATION ? "%17s" : "%9s",
433 
                       REGISTER_NAME (regnum));
434 
      col++;
435 
    }
436 
  printf_filtered ("\n      ");
437 
 
438 
  regnum = start_regnum;        /* go back to start of row */
439 
 
440 
  /* now print the values in hex, 4 or 8 to the row */
441 
  for (col = 0; col < ncols && regnum < numregs; regnum++)
442 
    {
443 
      /* unused register? */
444 
      if (*REGISTER_NAME (regnum) == '\0')
445 
        continue;
446 
 
447 
      /* end row: reached VF register? */
448 
      if (OR1K_IS_VF(regnum))
449 
        break;
450 
 
451 
      /* OK: get the data in raw format.  */
452 
      if (read_relative_register_raw_bytes (regnum, raw_buffer))
453 
        error ("can't read register %d (%s)", regnum, REGISTER_NAME (regnum));
454 
 
455 
      /* pad small registers */
456 
      for (byte = 0; byte < (OR1K_GPR_REGSIZE - REGISTER_VIRTUAL_SIZE (regnum)); byte++)
457 
        printf_filtered ("  ");
458 
 
459 
      /* Now print the register value in hex, endian order. */
460 
      if (TARGET_BYTE_ORDER == BIG_ENDIAN)
461 
        for (byte = REGISTER_RAW_SIZE (regnum) - REGISTER_VIRTUAL_SIZE (regnum);
462 
             byte < REGISTER_RAW_SIZE (regnum);
463 
             byte++)
464 
          printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
465 
      else
466 
        for (byte = REGISTER_VIRTUAL_SIZE (regnum) - 1;
467 
             byte >= 0;
468 
             byte--)
469 
          printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
470 
      printf_filtered (" ");
471 
      col++;
472 
    }
473 
 
474 
  /* ie. if we actually printed anything... */
475 
  if (col > 0)
476 
    printf_filtered ("\n");
477 
 
478 
  return regnum;
479 
}
480 
 
481 
/* Replacement for generic do_registers_info.
482 
   Print regs in pretty columns.  */
483 
 
484 
static void
485 
print_register (regnum, all)
486 
     int regnum, all;
487 
{
488 
  int offset;
489 
  char raw_buffer[MAX_REGISTER_RAW_SIZE];
490 
 
491 
  /* Get the data in raw format.  */
492 
  if (read_relative_register_raw_bytes (regnum, raw_buffer))
493 
    {
494 
      printf_filtered ("%s: [Invalid]", REGISTER_NAME (regnum));
495 
      return;
496 
    }
497 
 
498 
  /* If virtual format is floating, print it that way.  */
499 
  if (OR1K_IS_VF (regnum))
500 
    do_vf_register (regnum);
501 
  else
502 
    {
503 
      int byte;
504 
      printf_filtered ("%-16s\t", REGISTER_NAME (regnum));
505 
 
506 
      /* pad small registers */
507 
      for (byte = 0; byte < (OR1K_GPR_REGSIZE - REGISTER_VIRTUAL_SIZE (regnum)); byte++)
508 
        printf_filtered ("  ");
509 
 
510 
      /* Now print the register value in hex, endian order. */
511 
      if (TARGET_BYTE_ORDER == BIG_ENDIAN)
512 
        for (byte = REGISTER_RAW_SIZE (regnum) - REGISTER_VIRTUAL_SIZE (regnum);
513 
             byte < REGISTER_RAW_SIZE (regnum);
514 
             byte++)
515 
          printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
516 
      else
517 
        for (byte = REGISTER_VIRTUAL_SIZE (regnum) - 1;
518 
             byte >= 0;
519 
             byte--)
520 
          printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
521 
      printf_filtered (" ");
522 
    }
523 
}
524 
 
525 
/* DO_REGISTERS_INFO: called by "info register" command */
526 
 
527 
void
528 
or1k_do_registers_info (regnum, fpregs)
529 
     int regnum;
530 
     int fpregs;
531 
{
532 
  if (fpregs && !or1k_implementation.vf_present)
533 
    {
534 
      warning ("VF register set not present in this implementation.");
535 
      fpregs = 0;
536 
    }
537 
  if (regnum != -1)
538 
    {
539 
      /* do one specified register */
540 
      if (*(REGISTER_NAME (regnum)) == '\0')
541 
        error ("Not a valid register for the current processor type");
542 
 
543 
      print_register (regnum, 0);
544 
      printf_filtered ("\n");
545 
    }
546 
  else
547 
    /* do all (or most) registers */
548 
    {
549 
      regnum = 0;
550 
      while (regnum < NUM_REGS)
551 
        {
552 
          if (OR1K_IS_VF (regnum))
553 
            /* true for "INFO ALL-REGISTERS" command */
554 
            if (fpregs)
555 
              /* FP regs */
556 
              regnum = do_vf_register (regnum);
557 
            else
558 
              /* skip floating point regs */
559 
              regnum++;
560 
          else
561 
            /* GP (int) regs */
562 
            regnum = do_gp_register_row (regnum);
563 
        }
564 
    }
565 
}
566 
 
567 
/* Given the address at which to insert a breakpoint (BP_ADDR),
568 
   what will that breakpoint be?
569 
 
570 
   For or1k, we have a breakpoint instruction. Since all or1k
571 
   instructions are 32 bits, this is all we need, regardless of
572 
   address. K is not used.  */
573 
 
574 
unsigned char *
575 
or1k_breakpoint_from_pc (bp_addr, bp_size)
576 
     CORE_ADDR * bp_addr;
577 
     int *bp_size;
578 
{
579 
  static char breakpoint[] = BRK_INSTR_STRUCT;
580 
  *bp_size = OR1K_INSTLEN;
581 
  return breakpoint;
582 
}
583 
 
584 
/* Return the string for a signal.
585 
   Replacement for target_signal_to_string (sig).  NOT USED.  */
586 
 
587 
char
588 
*or1k_signal_to_string (sig)
589 
     enum target_signal sig;
590 
{
591 
  if ((sig >= TARGET_SIGNAL_FIRST) && (sig <= TARGET_SIGNAL_LAST))
592 
    return or1k_signals[sig].string;
593 
  else
594 
    if (sig <= TARGET_SIGNAL_LAST + NUM_OR1K_SIGNALS)
595 
      return or1k_signals[sig - TARGET_SIGNAL_LAST].string;
596 
    else
597 
      return 0;
598 
}
599 
 
600 
/* Return the name for a signal.  */
601 
 
602 
char *
603 
or1k_signal_to_name (sig)
604 
     enum target_signal sig;
605 
{
606 
  if (sig >= TARGET_SIGNAL_LAST)
607 
    if (sig <= TARGET_SIGNAL_LAST + NUM_OR1K_SIGNALS)
608 
      return or1k_signals[sig - TARGET_SIGNAL_LAST].name;
609 
    else
610 
 
611 
    /* I think the code which prints this will always print it along with
612 
       the string, so no need to be verbose.  */
613 
      return "?";
614 
  if (sig == TARGET_SIGNAL_UNKNOWN)
615 
    return "?";
616 
  return 0;
617 
}
618 
 
619 
/* Given a name, return its signal.  NOT USED.  */
620 
enum target_signal
621 
or1k_signal_from_name (name)
622 
     char *name;
623 
{
624 
  enum target_signal sig;
625 
 
626 
  /* It's possible we also should allow "SIGCLD" as well as "SIGCHLD"
627 
     for TARGET_SIGNAL_SIGCHLD.  SIGIOT, on the other hand, is more
628 
     questionable; seems like by now people should call it SIGABRT
629 
     instead.  */
630 
 
631 
  /* This ugly cast brought to you by the native VAX compiler.  */
632 
  for (sig = TARGET_SIGNAL_FIRST;
633 
       or1k_signal_to_name (sig) != NULL;
634 
       sig = (enum target_signal) ((int) sig + 1))
635 
    if (STREQ (name, or1k_signal_to_name (sig)))
636 
      return sig;
637 
  return TARGET_SIGNAL_UNKNOWN;
638 
}
639 
 
640 
/* Given a return value in `regbuf' with a type `valtype', extract and
641 
   copy its value into `valbuf'. */
642 
 
643 
void
644 
or1k_extract_return_value (valtype, regbuf, valbuf)
645 
     struct type *valtype;
646 
     char regbuf[REGISTER_BYTES];
647 
     char *valbuf;
648 
{
649 
  if (TYPE_CODE_FLT == TYPE_CODE (valtype))
650 
    memcpy (valbuf, &regbuf[REGISTER_BYTE (VFRV_REGNUM)], TYPE_LENGTH (valtype));
651 
  else
652 
    memcpy (valbuf, &regbuf[REGISTER_BYTE (RV_REGNUM)], TYPE_LENGTH (valtype));
653 
}
654 
 
655 363 markom 
/* The or1k cc defines the following
656 
   prologue:
657 
00000000 <_proc1>:
658 
   0:   d7 e1 17 e4     l.sw 0xffffffe4(r1),r2
659 
   4:   9c 41 00 00     l.addi r2,r1,0x0
660 
   8:   9c 21 ff e8     l.addi r1,r1,0xffffffe8
661 
   c:   d7 e2 1f f8     l.sw 0xfffffff8(r2),r3
662 
  10:   d7 e2 27 f4     l.sw 0xfffffff4(r2),r4
663 
  14:   84 82 ff f8     l.lwz r4,0xfffffff8(r2)
664 
  18:   9d 24 00 00     l.addi r9,r4,0x0
665 
  1c:   00 00 00 02     l.j 0x2
666 
  20:   15 00 00 00     l.nop
667 120 markom 
 
668 363 markom 
00000024 <_L2>:
669 
  24:   84 41 ff fc     l.lwz r2,0xfffffffc(r1)
670 
  28:   48 00 58 00     l.jalr r11
671 
  2c:   9c 21 00 18     l.addi r1,r1,0x18 */
672 120 markom 
 
673 363 markom 
CORE_ADDR
674 
or1k_skip_prologue (CORE_ADDR pc)
675 120 markom 
{
676 363 markom 
  unsigned long inst;
677 
  CORE_ADDR skip_pc;
678 
  CORE_ADDR func_addr, func_end;
679 
  struct symtab_and_line sal;
680 
  int i;
681 
  int offset = 0;
682 207 chris 
 
683 120 markom 
  for (i = 0; i < MAX_GPR_REGS; i++)
684 
    or1k_saved_reg_addr[i] = -1;
685 
 
686 362 markom 
  /* Is there a prologue?  */
687 
  inst = or1k_fetch_instruction (pc);
688 
  if ((inst & 0xfc1ff800) != 0xd4011000) return pc; /* l.sw I(r1),r2 */
689 
  or1k_saved_reg_addr[2] = offset++;
690 
  inst = or1k_fetch_instruction (pc + OR1K_INSTLEN);
691 
  if ((inst & 0xFFFF0000) != 0x9c410000) return pc; /* l.addi r2,r1,I */
692 
  pc += 2 * OR1K_INSTLEN;
693 
  inst = or1k_fetch_instruction (pc);
694 
  if ((inst & 0xFFFF0000) != 0x9c210000) return pc; /* l.addi r1,r1,I */
695 
  pc += OR1K_INSTLEN;
696 
 
697 
  /* Skip stored registers.  */
698 
  inst = or1k_fetch_instruction (pc);
699 
  while ((inst & 0xfc1ff800) != 0xd4020000)  /* l.sw 0x0(r2),rx */
700 207 chris 
    {
701 362 markom 
      /* get saved reg. */
702 
      or1k_saved_reg_addr[(inst >> 11) & 0x1f] = offset++;
703 
      pc += OR1K_INSTLEN;
704 
      inst = or1k_fetch_instruction (pc);
705 120 markom 
    }
706 363 markom 
  return pc;
707 120 markom 
}
708 
 
709 
/* Determines whether this function has frame.  */
710 
 
711 
int
712 
or1k_frameless_function_invocation (struct frame_info *fi)
713 
{
714 
  CORE_ADDR func_start, after_prologue;
715 
  int frameless;
716 
  func_start = (get_pc_function_start ((fi)->pc) + FUNCTION_START_OFFSET);
717 
  after_prologue = SKIP_PROLOGUE (func_start);
718 
 
719 
  /* If we don't skip pc, we don't have even shortest possible  prologue.  */
720 
  frameless = (after_prologue <= func_start);
721 
  return frameless;
722 
}
723 
 
724 
/* Given a GDB frame, determine the address of the calling function's frame.
725 
   This will be used to create a new GDB frame struct, and then
726 
   INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame. */
727 
 
728 
CORE_ADDR
729 
or1k_frame_chain (frame)
730 
     struct frame_info *frame;
731 
{
732 
  CORE_ADDR fp;
733 
  if (USE_GENERIC_DUMMY_FRAMES)
734 
    {
735 
      if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
736 
        /* dummy frame same as caller's frame */
737 
        return frame->frame;
738 
    }
739 
 
740 
  if (inside_entry_file (frame->pc) ||
741 
      frame->pc == entry_point_address ())
742 
    return 0;
743 
 
744 
  if (frame->signal_handler_caller)
745 
    fp = read_memory_integer (frame->frame, 4);
746 
  else if (frame->next != NULL
747 
           && frame->next->signal_handler_caller
748 
           && FRAMELESS_FUNCTION_INVOCATION (frame))
749 
    /* A frameless function interrupted by a signal did not change the
750 
       frame pointer.  */
751 
    fp = FRAME_FP (frame);
752 
  else
753 207 chris 
    {
754 
      unsigned long func_pc = get_pc_function_start(frame->pc);
755 
      unsigned long insn = read_memory_integer(func_pc,4);
756 
      int i;
757 
      int offset = 0;
758 120 markom 
 
759 207 chris 
      /* The first instruction should be the number of bytes
760 
         in our frame. If it isn't we're in trouble because
761 
         the function is without a prologue... */
762 
      if(((insn & 0xFC000000) == 0x9C000000) &&
763 
         ((insn & 0x03E00000) == 0x00200000) &&
764 
         ((insn & 0x001F0000) == 0x00010000))
765 
        {
766 
          short off = insn & 0xFFFF;
767 
 
768 
          /* Look for the storage of the frame pointer in the
769 
             function prologue.. */
770 
          for(i=1;i<20;i++)
771 
            {
772 
              unsigned long insn = read_memory_integer(func_pc+4*i,4);
773 
 
774 
              /* If bits are 31 - 26 are %110101,
775 
                 and bits 20 - 16 are %00001,
776 
                 and bits 15 - 11 are %00010,
777 
                 then our frame pointer lies at the offset specified
778 
                 by bits [25-21][10-0]. */
779 
 
780 
              int code = insn >> 26;
781 
              int r1    = (insn & 0x001F0000) >> 16;
782 
              int r2    = (insn & 0x0000F800) >> 11;
783 
              int idx_h = (insn & 0x03E00000) >> 10;
784 
              int idx   = (insn & 0x000007FF) | idx_h;
785 
 
786 
              if(code == 0x35 && r1 == 1 && r2 == 2)
787 
                {
788 
                  offset = off + idx;
789 
                  break;
790 
                }
791 
            }
792 
        }
793 
 
794 
      fp = read_memory_integer (frame->frame + offset, 4);
795 
    }
796 
 
797 120 markom 
  if (USE_GENERIC_DUMMY_FRAMES)
798 
    {
799 
      CORE_ADDR fpp, lr;
800 
 
801 
      lr = read_register (LR_REGNUM);
802 
      if (lr == entry_point_address ())
803 
        if (fp != 0 && (fpp = read_memory_integer (fp, 4)) != 0)
804 
          if (PC_IN_CALL_DUMMY (lr, fpp, fpp))
805 
            return fpp;
806 
    }
807 
 
808 
  return fp;
809 
}
810 
 
811 
/* The code to store, into a struct frame_saved_regs,
812 
   the addresses of the saved registers of frame described by FRAME_INFO.
813 
   This includes special registers such as pc and fp saved in special
814 
   ways in the stack frame.  sp is even more special:
815 
   the address we return for it IS the sp for the next frame.  */
816 
void
817 
or1k_init_saved_regs (struct frame_info *fi)
818 
{
819 
  int i;
820 
  CORE_ADDR frame_addr;
821 207 chris 
  CORE_ADDR func_pc = get_pc_function_start ((fi)->pc) + FUNCTION_START_OFFSET;
822 
  int frame_size;
823 
  int pc_found = 0;
824 
 
825 120 markom 
  frame_saved_regs_zalloc (fi);
826 
 
827 
  /* Skip prologue sets or1k_saved_reg_addr[], we will use it later.  */
828 207 chris 
  or1k_skip_prologue (func_pc);
829 120 markom 
 
830 207 chris 
  frame_size = or1k_saved_reg_addr[1];
831 
  or1k_saved_reg_addr[1] = -1;
832 
 
833 
  /* If the frame_size is less than 0, we have hit an assembly
834 
     routine which we can't traverse beyond. Let's give up here,
835 
     because attempting to continue will only lead to trouble. */
836 
  if(frame_size < 0)
837 
    {
838 
      printf("Found a function without a prologue at 0x%08x\n",func_pc);
839 
      printf("Frame pc was at 0x%08x\n",fi->pc);
840 
      return;
841 
    }
842 
 
843 120 markom 
  for (i = 0; i < NUM_GPR_REGS + NUM_VF_REGS; i++)
844 
    if (or1k_saved_reg_addr[i] >= 0)
845 207 chris 
      fi->saved_regs[i] = fi->frame - or1k_saved_reg_addr[i];
846 
 
847 
  /* We want to make sure we fill in the PC with the value of the
848 
     r9 register from the NEXT frame, and that the value of r1 is
849 
     the correct value of r1 for the next frame, which can be
850 
     calculated by adding the frame_size to the frame pointer. */
851 
  fi->saved_regs[1] = fi->frame - frame_size;
852 
 
853 
  if(fi->saved_regs[LR_REGNUM])
854 
    fi->saved_regs[PC_REGNUM] = read_memory_integer(fi->saved_regs[LR_REGNUM],4);
855 
  else
856 
    fi->saved_regs[PC_REGNUM] = read_register(LR_REGNUM);
857 120 markom 
}
858 
 
859 
static CORE_ADDR
860 
read_next_frame_reg (fi, regno)
861 
     struct frame_info *fi;
862 
     int regno;
863 
{
864 
  for (; fi; fi = fi->next)
865 
    {
866 
      /* We have to get the saved sp from the sigcontext
867 
         if it is a signal handler frame.  */
868 
      if (regno == SP_REGNUM && !fi->signal_handler_caller)
869 
        return fi->frame;
870 
      else
871 
        {
872 
          if (fi->saved_regs == NULL)
873 
            or1k_init_saved_regs (fi);
874 
          if (fi->saved_regs[regno])
875 207 chris 
            {
876 
              if(regno == SP_REGNUM || regno == PC_REGNUM)
877 
                return fi->saved_regs[regno];
878 
              else
879 
                return read_memory_integer (ADDR_BITS_REMOVE (fi->saved_regs[regno]), OR1K_GPR_REGSIZE);
880 
            }
881 120 markom 
        }
882 
    }
883 
  return read_register (regno);
884 
}
885 
 
886 
/* Find the caller of this frame.  We do this by seeing if LR_REGNUM
887 
   is saved in the stack anywhere, otherwise we get it from the
888 
   registers.  */
889 
 
890 
CORE_ADDR
891 
or1k_frame_saved_pc (fi)
892 
     struct frame_info *fi;
893 
{
894 
  CORE_ADDR saved_pc;
895 
 
896 
  /* We have to get the saved pc from the sigcontext
897 
     if it is a signal handler frame.  */
898 
  if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
899 
    saved_pc = read_memory_integer (fi->frame, OR1K_GPR_REGSIZE);
900 
  else
901 
    saved_pc = read_next_frame_reg (fi, PC_REGNUM);
902 
 
903 
  return ADDR_BITS_REMOVE (saved_pc);
904 
}
905 
 
906 
/* Discard from the stack the innermost frame, restoring all registers.  */
907 
 
908 
void
909 
or1k_pop_frame ()
910 
{
911 
  register int regnum;
912 
  struct frame_info *frame = get_current_frame ();
913 
  CORE_ADDR new_sp = FRAME_FP (frame);
914 
 
915 
  write_register (PC_REGNUM, FRAME_SAVED_PC (frame));
916 
  if (frame->saved_regs == NULL)
917 
    or1k_init_saved_regs (frame);
918 
  for (regnum = 0; regnum < NUM_REGS; regnum++)    {
919 
      if (regnum != SP_REGNUM && regnum != PC_REGNUM
920 
          && frame->saved_regs[regnum] >= 0)
921 
        write_register (regnum,
922 
                        read_memory_integer (frame->saved_regs[regnum],
923 
                                             OR1K_GPR_REGSIZE));
924 
    }
925 
  write_register (SP_REGNUM, new_sp);
926 
  flush_cached_frames ();
927 
}
928 
 
929 
CORE_ADDR
930 
or1k_push_arguments (nargs, args, sp, struct_return, struct_addr)
931 
     int nargs;
932 
     value_ptr *args;
933 
     CORE_ADDR sp;
934 
     int struct_return;
935 
     CORE_ADDR struct_addr;
936 
{
937 
  int argreg;
938 
  int float_argreg;
939 
  int argnum;
940 
  int len = 0;
941 
  int stack_offset = 0;
942 
 
943 
  /* Initialize the integer and float register pointers.  */
944 
  argreg = A0_REGNUM;
945 
  float_argreg = VFA0_REGNUM;
946 
 
947 
  /* The struct_return pointer occupies the RV value register.  */
948 
  if (struct_return)
949 
    write_register (RV_REGNUM, struct_addr);
950 
 
951 
  /* Now load as many as possible of the first arguments into
952 
     registers, and push the rest onto the stack.  Loop thru args
953 
     from first to last.  */
954 
  for (argnum = 0; argnum < nargs; argnum++)
955 
    {
956 
      char *val;
957 
      char valbuf[MAX_REGISTER_RAW_SIZE];
958 
      value_ptr arg = args[argnum];
959 
      struct type *arg_type = check_typedef (VALUE_TYPE (arg));
960 
      int len = TYPE_LENGTH (arg_type);
961 
      enum type_code typecode = TYPE_CODE (arg_type);
962 
 
963 
      /* The EABI passes structures that do not fit in a register by
964 
         reference. In all other cases, pass the structure by value.  */
965 
      if (len > OR1K_GPR_REGSIZE &&
966 
          (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION))
967 
        {
968 
          store_address (valbuf, OR1K_GPR_REGSIZE, VALUE_ADDRESS (arg));
969 
          typecode = TYPE_CODE_PTR;
970 
          len = OR1K_GPR_REGSIZE;
971 
          val = valbuf;
972 
        }
973 
      else
974 
        {
975 
          val = (char *) VALUE_CONTENTS (arg);
976 
 
977 
          if (typecode == TYPE_CODE_FLT
978 
              /* Doubles are not stored in regs on 32b target.  */
979 
              && len <= OR1K_VF_REGSIZE
980 
              && OR1K_VF_PRESENT)
981 
            {
982 
              if (float_argreg <= OR1K_LAST_FP_ARG_REGNUM)
983 
                {
984 
                  CORE_ADDR regval = extract_address (val, len);
985 
                  write_register (float_argreg++, regval);
986 
                }
987 
              else
988 
                {
989 
                  write_memory ((CORE_ADDR) sp, val, OR1K_VF_REGSIZE);
990 
                  sp -= OR1K_STACK_ALIGN;
991 
                }
992 
            }
993 
          else
994 
            {
995 
              if (argreg <= OR1K_LAST_ARG_REGNUM)
996 
                {
997 
                  CORE_ADDR regval = extract_address (val, len);
998 
                  write_register (argreg++, regval);
999 
                }
1000 
              else
1001 
                {
1002 
                  write_memory ((CORE_ADDR) sp, val, OR1K_GPR_REGSIZE);
1003 
                  sp -= OR1K_STACK_ALIGN;
1004 
                }
1005 
            }
1006 
        }
1007 
    }
1008 
 
1009 
  /* Return adjusted stack pointer.  */
1010 
  return sp;
1011 
}
1012 
 
1013 
/* Return nonzero when instruction has delay slot.  */
1014 372 markom 
 
1015 404 simons 
int
1016 120 markom 
is_delayed (insn)
1017 
     unsigned long insn;
1018 
{
1019 372 markom 
  int index;
1020 
  index = insn_decode (insn);
1021 
  return or32_opcodes[index].flags & OR32_IF_DELAY;
1022 120 markom 
}
1023 
 
1024 
int
1025 
or1k_step_skips_delay (pc)
1026 
     CORE_ADDR pc;
1027 
{
1028 
  char buf[OR1K_INSTLEN];
1029 
 
1030 
  if (target_read_memory (pc, buf, OR1K_INSTLEN) != 0)
1031 
    /* If error reading memory, guess that it is not a delayed branch.  */
1032 
    return 0;
1033 
  return is_delayed ((unsigned long) extract_unsigned_integer (buf, OR1K_INSTLEN));
1034 
}
1035 
 
1036 
CORE_ADDR
1037 
or1k_push_return_address (pc, sp)
1038 
     CORE_ADDR pc;
1039 
     CORE_ADDR sp;
1040 
{
1041 
  /* Set the return address register to point to the entry
1042 
     point of the program, where a breakpoint lies in wait.  */
1043 
  write_register (LR_REGNUM, CALL_DUMMY_ADDRESS ());
1044 
  return sp;
1045 
}
1046 
 
1047 
/* Parses args for spr name and puts result into group and index.  */
1048 
 
1049 
static char *
1050 
parse_spr_params (args, group, index)
1051 
                  char *args;
1052 
                  int *group, *index;
1053 
{
1054 
  *index = -1;
1055 
  if (args)
1056 
    {
1057 
      int i;
1058 
      char *ptr_c;
1059 
 
1060 
      /* Check if group number was supplied.  */
1061 
      ptr_c = args;
1062 
      while (*ptr_c != ' ' && *ptr_c != 0)
1063 
        ptr_c++;
1064 
      *ptr_c = 0;
1065 
 
1066 
      *group = (int) strtoul (args, &ptr_c, 0);
1067 
      if (*ptr_c != 0)
1068 
        {
1069 
          *group = OR1K_NUM_SPR_GROUPS;
1070 
 
1071 
          /* check for group name */
1072 
          for (i = 0; i < OR1K_NUM_SPR_GROUPS; i++)
1073 
            if (strcasecmp (or1k_group_names[i], args) == 0)
1074 
              {
1075 
                *group = i;
1076 
                break;
1077 
              }
1078 
 
1079 
          /* Invalid group => check all register names in all groups.  */
1080 
          if (*group >= OR1K_NUM_SPR_GROUPS)
1081 
            {
1082 
              for (i = 0; i < OR1K_NUM_SPR_GROUPS; i++)
1083 
                {
1084 
                  int regno;
1085 
                  regno = or1k_regno_from_name (i, args);
1086 
                  if (regno >= 0)
1087 
                    {
1088 
                      *group = i;
1089 
                      *index = regno;
1090 362 markom 
                      break;
1091 120 markom 
                    }
1092 
                }
1093 
            }
1094 
        }
1095 
      if (*group < 0 || *group >= OR1K_NUM_SPR_GROUPS)
1096 
        error ("Invalid group or register.\n");
1097 
 
1098 
      if (*index < 0)
1099 
        {
1100 603 markom 
          printf ("a'%s'\n", args);
1101 120 markom 
          args += strlen(args) + 1;
1102 603 markom 
          printf ("b'%s'\n", args);
1103 
          if (*args != 0)
1104 
            {
1105 
              ptr_c = args;
1106 
              while (*ptr_c != ' ' && *ptr_c != 0)
1107 
                ptr_c++;
1108 
              *ptr_c = 0;
1109 
 
1110 
              *index = (int) strtoul (args, &ptr_c, 0);
1111 
              if (*ptr_c != 0)
1112 
                *index = or1k_regno_from_name (*group, args);
1113 
            }
1114 120 markom 
 
1115 
          if (*index < 0)
1116 
            {
1117 
              printf_filtered ("No register supplied. Valid registers are:\n");
1118 
              for (i = 0; i < or1k_spr_valid_aliases[*group]; i++)
1119 
                {
1120 
                  char reg_name[16];
1121 362 markom 
                  char *gen_name = or1k_spr_register_name (SPR_REG(*group, i + or1k_group_name_start[*group]));
1122 120 markom 
                  sprintf (reg_name, "SPR%i_%i", *group, i);
1123 
                  if (strcmp (reg_name, gen_name) != 0)
1124 
                    printf_filtered ("%s\t", gen_name);
1125 
                }
1126 
              printf_filtered ("\n");
1127 
              return args + strlen(args) + 1;
1128 
            }
1129 
        }
1130 
    }
1131 
  else
1132 
    {
1133 
      /* No parameters - print groups */
1134 
      int i;
1135 
      printf_filtered ("No parameter supplied. Valid groups are:\n");
1136 
      for (i = 0; i < OR1K_NUM_SPR_GROUPS; i++)
1137 
        printf_filtered ("%s\t", or1k_group_names[i]);
1138 
      printf_filtered ("\nSingle register name or register name or number after the group can be also supplied.\n");
1139 
      return args;
1140 
    }
1141 
  return args + strlen(args) + 1;
1142 
}
1143 
 
1144 
/* SPR register info.  */
1145 
 
1146 
void
1147 
info_spr_command (args, from_tty)
1148 
     char *args;
1149 
     int from_tty;
1150 
{
1151 
  int group, index;
1152 
  parse_spr_params (args, &group, &index);
1153 
  if (index >= 0)
1154 
    {
1155 363 markom 
      unsigned long value = or1k_read_spr_reg (SPR_REG(group, index));
1156 362 markom 
      printf_unfiltered ("%s.%s = SPR%i_%i = %i(%x)\n", or1k_group_names[group],
1157 
                         or1k_spr_register_name (SPR_REG(group, index)), group, index, value, value);
1158 120 markom 
    }
1159 
}
1160 
 
1161 
/* Set SPR register.  */
1162 
 
1163 
void
1164 
spr_command (args, from_tty)
1165 
     char *args;
1166 
     int from_tty;
1167 
{
1168 
  int group, index;
1169 
  char *nargs = parse_spr_params (args, &group, &index);
1170 
  if (index >= 0)
1171 
    {
1172 
      unsigned long prev;
1173 
      unsigned long value;
1174 
      char *ptr_c;
1175 
 
1176 
      /* Any arguments left?  */
1177 
      if (args + strlen(args) >= nargs)
1178 
        error ("Invalid register value.");
1179 
 
1180 
      prev = or1k_read_spr_reg (SPR_REG(group, index));
1181 
 
1182 
      ptr_c = nargs;
1183 
      while (*ptr_c != ' ' && *ptr_c != 0)
1184 
        ptr_c++;
1185 
      *ptr_c = 0;
1186 
      value = strtoul (nargs, &ptr_c, 0);
1187 
      if (*ptr_c != 0)
1188 362 markom 
                                error ("Invalid register value.");
1189 
                        or1k_write_spr_reg (SPR_REG(group, index), value);
1190 
      printf_unfiltered ("%s.%s (SPR%i_%i) set to %i(%x), was:%i(%x)\n", or1k_group_names[group],
1191 120 markom 
                         or1k_spr_register_name (SPR_REG(group, index)), group, index,
1192 
                         value, value, prev, prev);
1193 
    }
1194 
}
1195 
 
1196 
/* Calls extended command on target.  */
1197 
 
1198 
void
1199 
sim_command (args, from_tty)
1200 
     char *args;
1201 
     int from_tty;
1202 
{
1203 
  or1k_sim_cmd (args, from_tty);
1204 
}
1205 
 
1206 
 
1207 
static union exp_element exp_error;
1208 
 
1209 
/* Parses compare variable and returns it into ct.  */
1210 
 
1211 
union exp_element * or1k_parse_ct (exp, ct)
1212 
     union exp_element *exp;
1213 
     int *ct;
1214 
{
1215 
  int i;
1216 
  if (exp->opcode != OP_INTERNALVAR)
1217 
    error ("Valid lvalue expected.");
1218 
  exp++;
1219 
 
1220 
  for (i = 1; i < NUM_CT_NAMES; i++)
1221 
    if (strcasecmp (compare_to_names[i], exp->internalvar->name) == 0) break;
1222 
 
1223 
  if (i >= NUM_CT_NAMES)
1224 
    error ("Invalid compare to operand.");
1225 
  *ct = i;
1226 
  exp++;
1227 
 
1228 
  if (exp->opcode != OP_INTERNALVAR)
1229 
    return &exp_error;
1230 
  exp++;
1231 
  return exp;
1232 
}
1233 
 
1234 
/* Parses compare value and returns it into cv.  */
1235 
 
1236 
union exp_element * or1k_parse_cv (exp, cv)
1237 
     union exp_element *exp;
1238 
     unsigned int *cv;
1239 
{
1240 
  switch (exp->opcode)
1241 
    {
1242 
    case UNOP_IND:
1243 
      exp++;
1244 
      exp = or1k_parse_cv (exp, cv);
1245 
      *cv = or1k_fetch_word (*cv);
1246 
      break;
1247 
    case OP_LONG:
1248 
      exp += 2;
1249 
      *cv = exp->longconst;
1250 
      exp += 2;
1251 
      break;
1252 
    case OP_REGISTER:
1253 
      exp++;
1254 
      *cv = read_register (exp->longconst);
1255 
      exp += 2;
1256 
      break;
1257 
    default:
1258 
      error ("Value expected.");
1259 
    }
1260 
  return exp;
1261 
}
1262 
 
1263 
/* Parse conditional.
1264 
   Puts freshly allocated array of matchpoints into match.  */
1265 
 
1266 
union exp_element *
1267 
or1k_parse_cond (exp, match, nmatch)
1268 
     union exp_element *exp;
1269 
     struct matchpoint **match;
1270 
     int *nmatch;
1271 
{
1272 
  unsigned int ct;
1273 
  *match = (struct matchpoint *) malloc (sizeof (struct matchpoint));
1274 
  *nmatch = 1;
1275 
  switch (exp->opcode)
1276 
    {
1277 
    case BINOP_EQUAL:
1278 
      (*match)->dcr.cc = CC_EQUAL;
1279 
      break;
1280 
    case BINOP_NOTEQUAL:
1281 
      (*match)->dcr.cc = CC_NEQUAL;
1282 
      break;
1283 
    case BINOP_LESS:
1284 
      (*match)->dcr.cc = CC_LESS;
1285 
      break;
1286 
    case BINOP_GTR:
1287 
      (*match)->dcr.cc = CC_GREAT;
1288 
      break;
1289 
    case BINOP_LEQ:
1290 
      (*match)->dcr.cc = CC_LESSE;
1291 
      break;
1292 
    case BINOP_GEQ:
1293 
      (*match)->dcr.cc = CC_GREATE;
1294 
      break;
1295 
    case BINOP_BITWISE_AND:
1296 
      (*match)->dcr.cc = CC_MASKED;
1297 
      break;
1298 
    default:
1299 
      return &exp_error;
1300 
    }
1301 
 
1302 
  exp++;
1303 
  (*match)->dcr.dp = 1;
1304 
  (*match)->dcr.sc = 0;
1305 
  if (exp->opcode == OP_INTERNALVAR)
1306 
    {
1307 
      exp = or1k_parse_ct (exp, &ct);
1308 
      exp = or1k_parse_cv (exp, &(*match)->dvr);
1309 
    }
1310 
  else
1311 
    {
1312 
      exp = or1k_parse_cv (exp, &(*match)->dvr);
1313 
      exp = or1k_parse_ct (exp, &ct);
1314 
    }
1315 
 
1316 
  (*match)->dcr.ct = ct;
1317 
  (*match)->chain_type = CHAINING_NONE;
1318 
  (*match)->cause_breakpoint = 0;
1319 
  return exp;
1320 
}
1321 
 
1322 
/* Parses expression with && or || operators.
1323 
   Puts freshly allocated array of matchpoints into match.
1324 
   valid & 1: && is allowed,
1325 
   valid & 2: || is allowed.  */
1326 
 
1327 
union exp_element *
1328 
or1k_parse_any (exp, match, nmatch, valid)
1329 
     union exp_element *exp;
1330 
     struct matchpoint **match;
1331 
     int *nmatch;
1332 
     int valid;
1333 
{
1334 
  union exp_element *tmp;
1335 
  int first_and_only = 0, first_or_only = 0;
1336 
  struct matchpoint *tmp_match1, *tmp_match2, *tmpm;
1337 
  int tmp_nmatch1, tmp_nmatch2, tmpn;
1338 
 
1339 
  switch (exp->opcode)
1340 
    {
1341 
    case BINOP_LOGICAL_AND:
1342 
      if (!(valid & 1))
1343 
        return &exp_error;
1344 
      exp++;
1345 
 
1346 
      /* Parse first argument.  */
1347 
      tmp = or1k_parse_any (exp, &tmp_match1, &tmp_nmatch1, 1);
1348 
      if (tmp == &exp_error)
1349 
        exp = or1k_parse_any (exp, &tmp_match1, &tmp_nmatch1, valid);
1350 
      else
1351 
        {
1352 
          /* and_only successful */
1353 
          exp = tmp;
1354 
          first_and_only = 1;
1355 
        }
1356 
      if (exp == &exp_error)
1357 
        return &exp_error;
1358 
 
1359 
      /* Parse second argument.  */
1360 
      if (first_and_only)
1361 
        exp = or1k_parse_any (exp, &tmp_match2, &tmp_nmatch2, valid);
1362 
      else
1363 
        exp = or1k_parse_any (exp, &tmp_match2, &tmp_nmatch2, 1);
1364 
 
1365 
      if (exp == &exp_error)
1366 
        return &exp_error;
1367 
 
1368 
      if (first_and_only)
1369 
        {
1370 
          /* Exchange structures, so that and_only is listed last.  */
1371 
          struct matchpoint *tmpm = tmp_match1;
1372 
          int tmpn = tmp_nmatch1;
1373 
          tmp_match1 = tmp_match2;
1374 
          tmp_nmatch1 = tmp_nmatch2;
1375 
          tmp_match2 = tmpm;
1376 
          tmp_nmatch2 = tmpn;
1377 
        }
1378 
 
1379 
      *nmatch = tmp_nmatch1 + tmp_nmatch2;
1380 
      *match = (struct matchpoint *)malloc (*nmatch * sizeof (struct matchpoint));
1381 
      memcpy (*match, tmp_match1, tmp_nmatch1 * sizeof (struct matchpoint));
1382 
      free (tmp_match1);
1383 
      tmp_match2[0].chain_type = CHAINING_AND;
1384 
      memcpy (*match + tmp_nmatch1, tmp_match2, tmp_nmatch2 * sizeof (struct matchpoint));
1385 
      free (tmp_match2);
1386 
      return exp;
1387 
 
1388 
    case BINOP_LOGICAL_OR:
1389 
      if (!(valid & 2))
1390 
        return &exp_error;
1391 
      exp++;
1392 
 
1393 
      /* Parse first argument.  */
1394 
      tmp = or1k_parse_any (exp, &tmp_match1, &tmp_nmatch1, 2);
1395 
      if (tmp == &exp_error)
1396 
        exp = or1k_parse_any (exp, &tmp_match1, &tmp_nmatch1, valid);
1397 
      else
1398 
        {
1399 
          /* and_only successful */
1400 
          exp = tmp;
1401 
          first_or_only = 1;
1402 
        }
1403 
      if (exp == &exp_error)
1404 
        return &exp_error;
1405 
 
1406 
      /* Parse second argument.  */
1407 
      if (first_or_only)
1408 
        exp = or1k_parse_any (exp, &tmp_match2, &tmp_nmatch2, valid);
1409 
      else
1410 
        exp = or1k_parse_any (exp, &tmp_match2, &tmp_nmatch2, 2);
1411 
 
1412 
      if (exp == &exp_error)
1413 
        return &exp_error;
1414 
 
1415 
      if (first_or_only)
1416 
        {
1417 
          /* Exchange structures, so that and_only is listed first.  */
1418 
          struct matchpoint *tmpm = tmp_match1;
1419 
          int tmpn = tmp_nmatch1;
1420 
          tmp_match1 = tmp_match2;
1421 
          tmp_nmatch1 = tmp_nmatch2;
1422 
          tmp_match2 = tmpm;
1423 
          tmp_nmatch2 = tmpn;
1424 
        }
1425 
 
1426 
      *nmatch = tmp_nmatch1 + tmp_nmatch2;
1427 
      *match = (struct matchpoint *)malloc (*nmatch * sizeof (struct matchpoint));
1428 
      memcpy (*match, tmp_match1, tmp_nmatch1 * sizeof (struct matchpoint));
1429 
      free (tmp_match1);
1430 
      tmp_match2[0].chain_type = CHAINING_OR;
1431 
      memcpy (*match + tmp_nmatch1, tmp_match2, tmp_nmatch2 * sizeof (struct matchpoint));
1432 
      free (tmp_match2);
1433 
      return exp;
1434 
 
1435 
    default:
1436 
      return or1k_parse_cond (exp, match, nmatch);
1437 
    }
1438 
}
1439 
 
1440 
/* Parses sequence of ||s.
1441 
   Puts freshly allocated array of matchpoints into match.  */
1442 
 
1443 
union exp_element *
1444 
or1k_parse_or (exp, match, nmatch, set_break)
1445 
     union exp_element *exp;
1446 
     struct matchpoint **match;
1447 
     int *nmatch;
1448 
     int set_break;
1449 
{
1450 
  struct matchpoint *tmp_match1, *tmp_match2;
1451 
  int tmp_nmatch1, tmp_nmatch2;
1452 
 
1453 
  switch (exp->opcode)
1454 
    {
1455 
    case BINOP_LOGICAL_OR:
1456 
      exp++;
1457 
      exp = or1k_parse_or (exp, &tmp_match1, &tmp_nmatch1);
1458 
      if (exp == &exp_error)
1459 
        return &exp_error;
1460 
 
1461 
      exp = or1k_parse_any (exp, &tmp_match2, &tmp_nmatch2, 3);
1462 
      if (set_break)
1463 
        {
1464 
          tmp_match1[tmp_nmatch1 - 1].cause_breakpoint = 1;
1465 
          tmp_match2[tmp_nmatch2 - 1].cause_breakpoint = 1;
1466 
        }
1467 
      *nmatch = tmp_nmatch1 + tmp_nmatch2;
1468 
      *match = (struct matchpoint *)malloc (*nmatch * sizeof (struct matchpoint));
1469 
      memcpy (*match, tmp_match1, tmp_nmatch1 * sizeof (struct matchpoint));
1470 
      free (tmp_match1);
1471 
      memcpy (*match + tmp_nmatch1, tmp_match2, tmp_nmatch2 * sizeof (struct matchpoint));
1472 
      free (tmp_match2);
1473 
      return exp;
1474 
 
1475 
    default:
1476 
      return or1k_parse_any (exp, match, nmatch, 3);
1477 
      if (set_break)
1478 
        (*match)[*nmatch - 1].cause_breakpoint = 1;
1479 
    }
1480 
}
1481 
 
1482 
/* Prints single matchpoint from specified struct.  */
1483 
 
1484 
static void
1485 
print_matchpoint_struct (mp)
1486 
     struct matchpoint *mp;
1487 
{
1488 
  printf_filtered ("%-6s (%i) %u, ON=%i, chain_type=%i, cause break=%i\n", compare_to_names[mp->dcr.ct],
1489 
                   mp->dcr.cc, mp->dvr, mp->dcr.dp, mp->chain_type, mp->cause_breakpoint);
1490 
}
1491 
 
1492 
/* Build watchpoint(s) based on given structure.  */
1493 
 
1494 
static void
1495 
set_matchpoints (match, nmatch)
1496 
     struct matchpoint *match;
1497 
     int nmatch;
1498 
{
1499 
  int i;
1500 
  debug_regs_changed = 1;
1501 
  sift_matchpoints ();
1502 
  for (i = 0; i < nmatch; i++)
1503 
    {
1504 
      int num = or1k_implementation.num_used_matchpoints;
1505 
      dcr[num] = match[i].dcr;
1506 
      dvr[num] = match[i].dvr;
1507 
 
1508 
      /* Set chaining bits.  */
1509 
      dmr1 &= ~(3 << (2 * num));
1510 
      dmr1 |= match[i].chain_type << (2 * num);
1511 
 
1512 
      /* Set watchpoint bits */
1513 
      dmr2 &= 1 << num;
1514 
      dmr2 |= match[i].cause_breakpoint << num;
1515 
      matchpoint_user_count[i]++;
1516 
      or1k_implementation.num_used_matchpoints++;
1517 
    }
1518 
}
1519 
 
1520 
/* Returns nonzero, if matchpoints [start .. start+nmatch-1] are
1521 
   equal to match record. */
1522 
 
1523 
static int
1524 
matchpoint_matches (start, match, nmatch)
1525 
     int start;
1526 
     struct matchpoint *match;
1527 
     int nmatch;
1528 
{
1529 
  int i;
1530 
  if (nmatch + start >= or1k_implementation.num_matchpoints)
1531 
    return 0;
1532 
 
1533 
  for (i = 0; i < nmatch; i++)
1534 
    {
1535 
      int j = i + start;
1536 
 
1537 
      /* Everything exept cause breakpoint must match.  */
1538 
      if (dcr[j].dp != match[i].dcr.dp
1539 
          || dcr[j].ct != match[i].dcr.ct
1540 
          || dcr[j].cc != match[i].dcr.cc
1541 
          || dcr[j].sc != match[i].dcr.sc
1542 
          || dvr[j] != match[i].dvr
1543 
          || match[i].chain_type != (dmr1 >> (2 * j)) & 3)
1544 
        return 0;
1545 
    }
1546 
  return 1;
1547 
}
1548 
 
1549 
static void
1550 
hwatch_command (arg, from_tty)
1551 
     char *arg;
1552 
     int from_tty;
1553 
{
1554 
  struct expression *exp;
1555 
  int i, nfree, nmatch, remove = 0;
1556 
  struct matchpoint *match;
1557 
 
1558 
  if (arg == NULL)
1559 
    arg = "";
1560 
  if (strncasecmp ("remove ", arg, 7) == 0)
1561 
    {
1562 
      arg += 7;
1563 
      remove = 1;
1564 
    }
1565 
 
1566 
  /* Parse arguments.  */
1567 
  exp = parse_exp_1 (&arg, 0, 0);
1568 
 
1569 
#ifdef DEBUG
1570 
  dump_prefix_expression (exp, gdb_stdout, "expr1");
1571 
#endif
1572 
 
1573 
  if (or1k_parse_or (&exp->elts[0], &match, &nmatch, 1) == &exp_error)
1574 
    error ("Watchpoint too complex.");
1575 
 
1576 
  for (i = 0; i < nmatch; i++)
1577 
    print_matchpoint_struct (&match[i]);
1578 
 
1579 
  if (remove)
1580 
    {
1581 
      int start = -1;
1582 
      int cleared = 0;
1583 
 
1584 
      if (num_hw_watches <= 0)
1585 
        error ("No extended hardware supported watchpoints present.");
1586 
 
1587 
      for (i = 0; i < num_hw_watches; i++)
1588 
        if (matchpoint_matches (or1k_hwatch[i].matchpoint_start, match, nmatch))
1589 
          {
1590 
            start = or1k_hwatch[i].matchpoint_start;
1591 
            break;
1592 
          }
1593 
 
1594 
      if (start < 0)
1595 
        error ("Watchpoint not found.");
1596 
 
1597 
      for (i = 0; i < nmatch; i++)
1598 
        {
1599 
          int j = start + i;
1600 
          if (--matchpoint_user_count[j] <= 0)
1601 
            {
1602 
              debug_regs_changed = 1;
1603 
              memset (&dcr[j], 0, sizeof (dcr[j]));
1604 
              or1k_implementation.num_used_matchpoints--;
1605 
              cleared = 1;
1606 
            }
1607 
        }
1608 
      if (!cleared)
1609 
        warning ("No matchpoint(s) freed. Resources are busy.");
1610 
    }
1611 
  else
1612 
    {
1613 
      if (num_hw_watches >= MAX_HW_WATCHES)
1614 
        error ("Number of watchpoints too large.");
1615 
 
1616 
      /* Now we have to find out if given prefix expression matches
1617 
         our HW based support. It may take up to
1618 
         or1k_implementation.num_matchpoints - or1k_implementation.num_used_matchpoints. */
1619 
      nfree = or1k_implementation.num_matchpoints - or1k_implementation.num_used_matchpoints;
1620 
 
1621 
      if (nmatch > nfree)
1622 
        error ("Not enough free matchpoint resources.");
1623 
 
1624 
      /* Build watchpoint(s) based on just built structure.  */
1625 
      or1k_hwatch[num_hw_watches].matchpoint_start = or1k_implementation.num_used_matchpoints;
1626 
      set_matchpoints (match, nmatch);
1627 
      num_hw_watches++;
1628 
      printf_unfiltered ("Watchpoint successfully allocated.\n");
1629 
    }
1630 
  free (match);
1631 
  free (exp);
1632 
}
1633 
 
1634 
static void
1635 
htrace_command (args, from_tty)
1636 
     char *args;
1637 
     int from_tty;
1638 
{
1639 
  help_list (htrace_cmdlist, "htrace ", all_commands, gdb_stdout);
1640 
}
1641 
 
1642 
static void
1643 
htrace_mode_command (args, from_tty)
1644 
     char *args;
1645 
     int from_tty;
1646 
{
1647 
  help_list (htrace_mode_cmdlist, "htrace mode ", all_commands, gdb_stdout);
1648 
}
1649 
 
1650 
static void
1651 
htrace_mode_contin_command (args, from_tty)
1652 
     char *args;
1653 
     int from_tty;
1654 
{
1655 
  or1k_htrace.moder.contin = 1;
1656 
  printf_unfiltered ("Continuous trace mode set.\n");
1657 
}
1658 
 
1659 
static void
1660 
htrace_mode_suspend_command (args, from_tty)
1661 
     char *args;
1662 
     int from_tty;
1663 
{
1664 
  or1k_htrace.moder.contin = 0;
1665 
  printf_unfiltered ("Suspend trace mode set.\n");
1666 
}
1667 
 
1668 
static void print_event_struct (event, stop)
1669 
     struct htrace_event_struct *event;
1670 
     int stop;
1671 
{
1672 
  int i;
1673 
  if (event->operation == TRIGOP_ANY)
1674 
    if (stop)
1675 
      printf_filtered ("not active");
1676 
    else
1677 
      printf_filtered ("always active");
1678 
  else
1679 
    {
1680 
      char *comma;
1681 
      if (event->operation == TRIGOP_AND)
1682 
        comma = "&(";
1683 
      else
1684 
        comma = "|(";
1685 
 
1686 
      if (event->is_valid)
1687 
        {
1688 
          printf_filtered ("%s%s", comma, or1k_is_names[event->is_trig]);
1689 
          comma = ", ";
1690 
        }
1691 
      if (event->ls_valid)
1692 
        {
1693 
          printf_filtered ("%s%s", comma, or1k_ls_names[event->ls_trig]);
1694 
          comma = ", ";
1695 
        }
1696 
      if (event->bp_valid)
1697 
        {
1698 
          printf_filtered ("%sbreak", comma);
1699 
          comma = ", ";
1700 
        }
1701 
      if (event->wp_valid)
1702 
        for (i = 0; i < 11; i++)
1703 
          if ((event->wp_trig >> i) & 1)
1704 
            {
1705 
              printf_filtered ("%sWP%i", comma, i);
1706 
              comma = ", ";
1707 
            }
1708 
      if (comma[0] == ',')
1709 
        printf_filtered (")");
1710 
      else
1711 
        printf_filtered ("not active");
1712 
    }
1713 
}
1714 
 
1715 
static void
1716 
print_record_struct (record)
1717 
     struct htrace_record_struct *record;
1718 
{
1719 
  int i;
1720 
  char *comma = "";
1721 
  for (i = 0; i < MAX_RECORD_NAMES; i++)
1722 
    {
1723 
      if ((record->rec >> i)&1)
1724 
        {
1725 
          printf_filtered ("%s%s", comma, or1k_record_names[i]);
1726 
          comma = ", ";
1727 
        }
1728 
    }
1729 
  if (!*comma)
1730 
    printf_unfiltered ("none");
1731 
}
1732 
 
1733 
static void
1734 
htrace_info_command (args, from_tty)
1735 
     char *args;
1736 
     int from_tty;
1737 
{
1738 
  int i;
1739 
  printf_filtered ("Trace trigger: ");
1740 
  print_event_struct (&or1k_htrace.trig, 0);
1741 
  printf_filtered ("\nTrace qualifier: ");
1742 
  print_event_struct (&or1k_htrace.qual, 0);
1743 
  for (i = 0; i < MAX_MATCHPOINTS; i++)
1744 
    {
1745 
      printf_filtered ("\n WP%i records: ", i);
1746 
      print_record_struct (&or1k_htrace.recwp[i]);
1747 
    }
1748 
  printf_filtered ("\n BP records: ");
1749 
  print_record_struct (&or1k_htrace.recbp);
1750 
  printf_filtered ("\nTrace stop: ");
1751 
  print_event_struct (&or1k_htrace.stop, 1);
1752 
  printf_filtered ("\n");
1753 
}
1754 
 
1755 
/* Parses event from given string.
1756 
   Result is placed into event structure, and previously allocated
1757 
   resources are freed.  Parameter stop is nonzero, when we are parsing
1758 
   for stop criteria.  */
1759 
 
1760 
static void
1761 
parse_event (args, event, stop)
1762 
     char *args;
1763 
     struct htrace_event_struct *event;
1764 
     int stop;
1765 
{
1766 
  int i, op_type = 0, was_last_op = 1, any = 0;
1767 
 
1768 
  /* Release previous resources.  */
1769 
  for (i = 0; i < MAX_MATCHPOINTS; i++)
1770 
    {
1771 
      if ((event->wp_trig << i) & 1)
1772 
        if (--matchpoint_user_count[i] <= 0)
1773 
          {
1774 
            memset (&dcr[i], 0, sizeof (dcr[i]));
1775 
            debug_regs_changed = 1;
1776 
            or1k_implementation.num_used_matchpoints--;
1777 
          }
1778 
    }
1779 
 
1780 
  event->is_valid = event->is_trig = 0;
1781 
  event->ls_valid = event->ls_trig = 0;
1782 
  event->bp_valid = event->bp_trig = 0;
1783 
  event->wp_valid = event->wp_trig = 0;
1784 
 
1785 
  if (args == NULL)
1786 
    args = "";
1787 
  while (*args == ' ')
1788 
    args++;
1789 
 
1790 
  while (*args != '\0')
1791 
    {
1792 
      if (strncasecmp ("breakpoint", args, 10) == 0)
1793 
        {
1794 
          if (!was_last_op)
1795 
            error ("Syntax error.");
1796 
          was_last_op = 0;
1797 
          event->bp_valid = event->bp_trig = 1;
1798 
        }
1799 
      else if (!stop && strncasecmp ("any", args, 3) == 0
1800 
               || stop && strncasecmp ("none", args, 4) == 0)
1801 
        {
1802 
          if (!was_last_op)
1803 
            error ("Syntax error.");
1804 
          was_last_op = 0;
1805 
          any = 1;
1806 
        }
1807 
      else if (strncasecmp ("||", args, 2) == 0)
1808 
        {
1809 
          if (op_type == TRIGOP_AND)
1810 
            error ("Only one type of logical operator allowed at a time.");
1811 
          op_type = TRIGOP_OR;
1812 
          if (was_last_op)
1813 
            error ("Syntax error.");
1814 
          was_last_op = 1;
1815 
          args += 2;
1816 
        }
1817 
      else if (strncasecmp ("&&", args, 2) == 0)
1818 
        {
1819 
          if (op_type == TRIGOP_OR)
1820 
            error ("Only one type of logical operator allowed at a time.");
1821 
          op_type = TRIGOP_AND;
1822 
          if (was_last_op)
1823 
            error ("Syntax error.");
1824 
          was_last_op = 1;
1825 
          args += 2;
1826 
        }
1827 
      else
1828 
        {
1829 
          int found = 0;
1830 
          if (!was_last_op)
1831 
            error ("Syntax error.");
1832 
          was_last_op = 0;
1833 
 
1834 
          /* Search through is and ls tables for a match.  */
1835 
          for (i = 0; i < MAX_IS_NAMES; i++)
1836 
            if (strncasecmp (args, or1k_is_names[i], strlen (or1k_is_names[i])) == 0)
1837 
              {
1838 
                event->is_valid = 1;
1839 
                event->is_trig = i;
1840 
                args +=  strlen (or1k_is_names[i]);
1841 
                found = 1;
1842 
                break;
1843 
              }
1844 
          if (!found)
1845 
            {
1846 
              for (i = 0; i < MAX_LS_NAMES; i++)
1847 
                if (strncasecmp (args, or1k_ls_names[i], strlen (or1k_ls_names[i])) == 0)
1848 
                  {
1849 
                    event->ls_valid = 1;
1850 
                    event->ls_trig = i;
1851 
                    args +=  strlen (or1k_ls_names[i]);
1852 
                    found = 1;
1853 
                    break;
1854 
                  }
1855 
            }
1856 
          if (!found)
1857 
            {
1858 
              /* No special name was found => parse expression.  */
1859 
              struct expression *exp;
1860 
              struct matchpoint *match;
1861 
              int nmatch, nfree;
1862 
 
1863 
              exp = parse_exp_1 (&args, 0, 0);
1864 
 
1865 
              if (or1k_parse_any (&exp->elts[0], &match, &nmatch, 3) == &exp_error)
1866 
                error ("Expression too complex.");
1867 
              for (i = 0; i < nmatch; i++)
1868 
                print_matchpoint_struct (&match[i]);
1869 
 
1870 
              /* Now we have to find out if given prefix expression matches
1871 
                 our HW based support. It may take up to
1872 
                 or1k_implementation.num_matchpoints - or1k_implementation.num_used_matchpoints. */
1873 
              nfree = or1k_implementation.num_matchpoints - or1k_implementation.num_used_matchpoints;
1874 
 
1875 
              if (nmatch > nfree)
1876 
                error ("Not enough free matchpoint resources.");
1877 
 
1878 
              /* Build matchpoint(s) based on just built structure.  */
1879 
              set_matchpoints (match, nmatch);
1880 
              event->wp_valid = 1;
1881 
              event->wp_trig |= 1 << (or1k_implementation.num_used_matchpoints - 1);
1882 
              printf_unfiltered ("Watchpoint successfully allocated.\n");
1883 
              free (match);
1884 
              free (exp);
1885 
              found = 1;
1886 
            }
1887 
          if (!found)
1888 
            warning ("Invalid event at '%s'", args);
1889 
        }
1890 
      while (*args == ' ') args++;
1891 
    }
1892 
  if (any)
1893 
    event->operation = TRIGOP_ANY;
1894 
  else
1895 
    {
1896 
      if (op_type == 0)
1897 
        op_type = TRIGOP_AND;
1898 
      event->operation = op_type;
1899 
    }
1900 
}
1901 
 
1902 
static void
1903 
htrace_trigger_command (args, from_tty)
1904 
     char *args;
1905 
     int from_tty;
1906 
{
1907 
  parse_event (args, &or1k_htrace.trig, 0);
1908 
  printf_filtered ("Trace starts, when:\n");
1909 
  print_event_struct (&or1k_htrace.trig, 0);
1910 
  printf_filtered ("\n");
1911 
}
1912 
 
1913 
static void
1914 
htrace_qualifier_command (args, from_tty)
1915 
     char *args;
1916 
     int from_tty;
1917 
{
1918 
  parse_event (args, &or1k_htrace.qual, 0);
1919 
  printf_filtered ("Trace records, when:\n");
1920 
  print_event_struct (&or1k_htrace.qual, 0);
1921 
  printf_filtered ("\n");
1922 
}
1923 
 
1924 
static void
1925 
htrace_stop_command (args, from_tty)
1926 
     char *args;
1927 
     int from_tty;
1928 
{
1929 
  parse_event (args, &or1k_htrace.stop, 1);
1930 
  printf_filtered ("Trace stops, when:\n");
1931 
  print_event_struct (&or1k_htrace.stop, 1);
1932 
  printf_filtered ("\n");
1933 
}
1934 
 
1935 
static void
1936 
htrace_clear_records_command (args, from_tty)
1937 
     char *args;
1938 
     int from_tty;
1939 
{
1940 
  int i, j, cleared = 0;
1941 
 
1942 
  /* Clear all. */
1943 
  for (i = 0; i < MAX_MATCHPOINTS; i++)
1944 
    {
1945 
      for (j = 0; j < MAX_MATCHPOINTS; j++)
1946 
        {
1947 
          if ((or1k_htrace.wp_record_uses[i] << j) & 1)
1948 
            if (--matchpoint_user_count[j] <= 0)
1949 
            {
1950 
              memset (&dcr[j], 0, sizeof (dcr[j]));
1951 
              debug_regs_changed = 1;
1952 
              cleared = 1;
1953 
              or1k_implementation.num_used_matchpoints--;
1954 
            }
1955 
        }
1956 
      or1k_htrace.wp_record_uses[i] = 0;
1957 
    }
1958 
  if (!cleared)
1959 
    warning ("No matchpoints freed. Resources are busy.");
1960 
}
1961 
 
1962 
/* Syntax: htrace record {data}* when {expr} */
1963 
 
1964 
static void
1965 
htrace_record_command (args, from_tty)
1966 
     char *args;
1967 
     int from_tty;
1968 
{
1969 
  struct expression *exp;
1970 
  int i, nfree, nmatch, wp;
1971 
  struct matchpoint *match;
1972 
  unsigned int recdata = 0;
1973 
  char *c;
1974 
 
1975 
  if (args == '\0')
1976 
    error ( "Please specify data to record, e.g.:\n"
1977 
            "htrace record PC SDATA when $SEA == 100\n"
1978 
            "htrace record when $SEA == 100 to remove record");
1979 
 
1980 
  for (i = 0; *args != '\0' && strncasecmp ("when ", args, 5); i++)
1981 
    {
1982 
      int j, found = 0;
1983 
      for (j = 0; j < MAX_RECORD_NAMES; j++)
1984 
        if (strncasecmp (args, or1k_record_names[j], strlen (or1k_record_names[j])) == 0)
1985 
          {
1986 
            recdata |= 1 << j;
1987 
            found = 1;
1988 
            break;
1989 
          }
1990 
      if (!found)
1991 
        warning ("Invalid record data name at '%s'.", args);
1992 
      while (*args != ' ' && *args != '\0') args++;
1993 
      while (*args == ' ') args++;
1994 
    }
1995 
 
1996 
  if (strncasecmp ("when ", args, 5) != 0)
1997 
    if (*args == '\0')
1998 
      {
1999 
        warning ("Condition not set. Assuming breakpoint.");
2000 
        wp = -1;
2001 
      }
2002 
    else
2003 
      error ("Syntax error.");
2004 
  else
2005 
    {
2006 
      args += 5;
2007 
      if (strcasecmp ("breakpoint", args) == 0)
2008 
        wp = -1;
2009 
      else
2010 
        {
2011 
          /* Parse arguments.  */
2012 
          exp = parse_exp_1 (&args, 0, 0);
2013 
 
2014 
#ifdef DEBUG
2015 
          dump_prefix_expression (exp, gdb_stdout, "expr1");
2016 
#endif
2017 
          if (or1k_parse_any (&exp->elts[0], &match, &nmatch, 3) == &exp_error)
2018 
            error ("Expression too complex.");
2019 
 
2020 
          for (i = 0; i < nmatch; i++)
2021 
            print_matchpoint_struct (&match[i]);
2022 
 
2023 
          if (recdata)
2024 
            {
2025 
              /* Now we have to find out if given prefix expression matches
2026 
                 our HW based support. It may take up to
2027 
                 or1k_implementation.num_matchpoints - or1k_implementation.num_used_matchpoints. */
2028 
              nfree = or1k_implementation.num_matchpoints - or1k_implementation.num_used_matchpoints;
2029 
 
2030 
              if (nmatch > nfree)
2031 
                error ("Not enough free matchpoint resources.");
2032 
 
2033 
              wp = or1k_implementation.num_used_matchpoints - 1;
2034 
              or1k_htrace.wp_record_uses[wp] = 0;
2035 
              for (i = or1k_implementation.num_used_matchpoints; i <= wp; i++)
2036 
                or1k_htrace.wp_record_uses[wp] |= 1 << i;
2037 
              set_matchpoints (match, nmatch);
2038 
            }
2039 
          else
2040 
            {
2041 
              /* Remove record. */
2042 
              int start = -1, cleared = 0;
2043 
 
2044 
              for (i = 0; i < MAX_MATCHPOINTS; i++)
2045 
                {
2046 
                  int mp_start = 0, j;
2047 
                  j = or1k_htrace.wp_record_uses[i];
2048 
                  while (j > 0 && j & 1 == 0)
2049 
                    mp_start++;
2050 
 
2051 
                  if (matchpoint_matches (mp_start, match, nmatch))
2052 
                    {
2053 
                      start = mp_start;
2054 
                      or1k_htrace.wp_record_uses[i] = 0;
2055 
                      break;
2056 
                    }
2057 
                }
2058 
              if (start < 0)
2059 
                error ("Record with such expression not found.");
2060 
 
2061 
              for (i = 0; i < nmatch; i++)
2062 
                {
2063 
                  int j = i + start;
2064 
                  if (--matchpoint_user_count[j] <= 0)
2065 
                    {
2066 
                      memset (&dcr[j], 0, sizeof (dcr[j]));
2067 
                      debug_regs_changed = 1;
2068 
                      cleared = 1;
2069 
                    }
2070 
                }
2071 
              if (!cleared)
2072 
                warning ("No matchpoint(s) freed.");
2073 
            }
2074 
        }
2075 
    }
2076 
 
2077 
  /* If we reached this point we have matchpoints set, and wp
2078 
     holds the value of that watchpoint.  wp == -1, if breakpoint
2079 
     was specified.  */
2080 
  if (wp < 0)
2081 
    or1k_htrace.recbp.rec = recdata;
2082 
  else
2083 
    or1k_htrace.recwp[wp].rec = recdata;
2084 
 
2085 
  if (recdata)
2086 
    {
2087 
      printf_unfiltered ("Data");
2088 
      for (i = 0; i < MAX_RECORD_NAMES; i++)
2089 
        if ((recdata >> i) & 1)
2090 
          printf_unfiltered (" %s,", or1k_record_names[i]);
2091 
    }
2092 
  else
2093 
    printf_unfiltered ("No data");
2094 
  if (wp < 0)
2095 
    printf_unfiltered (" will be recorded when breakpoint occurs\n");
2096 
  else
2097 
    printf_unfiltered (" will be recorded when watchpoint #%i occurs\n", wp);
2098 
}
2099 
 
2100 
static void
2101 
htrace_enable_command (args, from_tty)
2102 
     char *args;
2103 
     int from_tty;
2104 
{
2105 
  or1k_htrace.moder.trace_enable = 1;
2106 
  printf_unfiltered ("HW Trace enabled.\n");
2107 
}
2108 
 
2109 
static void
2110 
htrace_disable_command (args, from_tty)
2111 
     char *args;
2112 
     int from_tty;
2113 
{
2114 
  or1k_htrace.moder.trace_enable = 0;
2115 
  printf_unfiltered ("HW Trace disabled.\n");
2116 
}
2117 
 
2118 
static void
2119 
htrace_rewind_command (args, from_tty)
2120 
     char *args;
2121 
     int from_tty;
2122 
{
2123 
  FILE *f;
2124 
  if (args != NULL && *args != '\0')
2125 
    strncpy (TRACE_FILENAME, args, TRACE_FILENAME_SIZE);
2126 
 
2127 
  /* Just empty it.  */
2128 
  if ((f = fopen (TRACE_FILENAME, "wb+")) == NULL)
2129 
    error ("Cannot open trace file.");
2130 
  fclose (f);
2131 
  printf_unfiltered ("Trace data cleared.\n");
2132 
}
2133 
 
2134 
static void
2135 
print_data_struct (pos, data)
2136 
     unsigned int pos;
2137 
     struct htrace_data_struct *data;
2138 
{
2139 
  struct symbol *func;
2140 
  char *funname = NULL;
2141 
 
2142 
  if (data->type < 4)
2143 
    {
2144 
      /* Determine function name - copied from stack.c  */
2145 
      func = find_pc_function (data->data);
2146 
      if (func)
2147 
        {
2148 
          struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (data->data);
2149 
          if (msymbol != NULL
2150 
              && (SYMBOL_VALUE_ADDRESS (msymbol)
2151 
                  > BLOCK_START (SYMBOL_BLOCK_VALUE (func))))
2152 
            funname = SYMBOL_NAME (msymbol);
2153 
          else
2154 
            {
2155 
              char *demangled;
2156 
              funname = SYMBOL_NAME (func);
2157 
              if (SYMBOL_LANGUAGE (func) == language_cplus)
2158 
                {
2159 
                  demangled = cplus_demangle (funname, DMGL_ANSI);
2160 
                  if (demangled == NULL)
2161 
                    funname = SYMBOL_SOURCE_NAME (func);
2162 
                }
2163 
            }
2164 
        }
2165 
      else
2166 
        {
2167 
          struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (data->data);
2168 
          if (msymbol != NULL)
2169 
            funname = SYMBOL_NAME (msymbol);
2170 
        }
2171 
    }
2172 
 
2173 
  printf_filtered ("%06X%c %-8s %08X", pos, data->valid ? '>' : ':',
2174 
                   or1k_record_names[data->type], data->data);
2175 
  if (funname)
2176 
    printf_filtered (" (%s)\n", funname);
2177 
  else
2178 
    printf_filtered ("\n");
2179 
}
2180 
 
2181 
/* Prints out trace buffer.  */
2182 
 
2183 
static void
2184 
htrace_print_command (args, from_tty)
2185 
     char *args;
2186 
     int from_tty;
2187 
{
2188 
  int i, from = 0, length = prev_length;
2189 
  FILE *f;
2190 
  struct htrace_data_struct *td;
2191 
 
2192 
  if (args == NULL) args = "";
2193 
  while (*args == ' ') args++;
2194 
  if (*args == '\0')
2195 
    {
2196 
      /* We will display buffer further. */
2197 
      from = prev_from + prev_length;
2198 
    }
2199 
  else
2200 
    {
2201 
      /* Display buffer range.  */
2202 
      int numbers = 0;
2203 
      char *cnum = args;
2204 
      while (*args != ' ' && *args != '\0')
2205 
        args++;
2206 
 
2207 
      /* Any arguments?  */
2208 
      if (*args == '\0')
2209 
        numbers = 1;
2210 
      else
2211 
        {
2212 
          *args = 0;
2213 
          args++;
2214 
          numbers = 2;
2215 
        }
2216 
      from = strtoul (cnum, &cnum, 0);
2217 
      if (*cnum != 0)
2218 
        error ("Invalid from value.");
2219 
      if (from < 0) from += trace_size;
2220 
      if (numbers == 2)
2221 
        {
2222 
          while (*args == ' ') args++;
2223 
          length = strtoul (cnum, &cnum, 0);
2224 
          if (*args != 0)
2225 
            error ("Invalid length value.");
2226 
          if (length < 0)
2227 
            {
2228 
              from += length;
2229 
              length = -length;
2230 
            }
2231 
        }
2232 
    }
2233 
 
2234 
  if (from >= trace_size)
2235 
    from = trace_size - 1;
2236 
  if (from < 0)
2237 
    from = 0;
2238 
  if (from + length >= trace_size)
2239 
    length = trace_size - from;
2240 
 
2241 
  prev_length = length;
2242 
  prev_from = from;
2243 
  if (length == 0)
2244 
    error ("Nothing to print.");
2245 
 
2246 
  printf_filtered ("Trace buffer %06x:%06x (size = %i)\n", from, from + length - 1, length);
2247 
  if ((f = fopen (TRACE_FILENAME, "rb")) == NULL)
2248 
    error ("Cannot open trace file.");
2249 
  if (fseek (f, TRACE_DATA_SIZE * from, SEEK_SET))
2250 
    error ("Error reading trace file.");
2251 
  td = (struct htrace_data_struct *) malloc (TRACE_DATA_SIZE * length);
2252 
  length = fread (td, TRACE_DATA_SIZE, length, f);
2253 
  for (i = 0; i < length; i++)
2254 
    print_data_struct (from + i, td[i]);
2255 
  fclose (f);
2256 
}
2257 
 
2258 149 chris 
int print_insn_big_or32 (bfd_vma,struct disassemble_info*);
2259 
int print_insn_little_or32 (bfd_vma,struct disassemble_info*);
2260 
 
2261 120 markom 
void
2262 
_initialize_or1k_tdep ()
2263 
{
2264 372 markom 
  build_automata ();
2265 149 chris 
  /* Added by CZ 26/06/01 */
2266 
  if(TARGET_BYTE_ORDER == BIG_ENDIAN)
2267 
    tm_print_insn = print_insn_big_or32;
2268 
  else
2269 
    tm_print_insn = print_insn_little_or32;
2270 363 markom 
 
2271 120 markom 
  /* Commands to show and set sprs.  */
2272 
  add_info ("spr", info_spr_command, "Show information about the spr registers.");
2273 
  add_com ("spr", class_support, spr_command, "Set specified SPR register.");
2274 
 
2275 
  /* hwatch command.  */
2276 207 chris 
  add_com ("hwatch", class_breakpoint, hwatch_command, "Set hardware watch"
2277 
           "point.\nExample: ($LEA == my_var)&&($LDATA < 50)||($SEA == my_"
2278 
           "var)&&($SDATA >= 50).\nSee OR1k Architecture document for more"
2279 
           " info.");
2280 120 markom 
 
2281 
  /* htrace commands.  */
2282 
  add_prefix_cmd ("htrace", class_breakpoint, htrace_command,
2283 
                  "Group of commands for handling hardware assisted trace\n\n"
2284 
                  "See OR1k Architecture and gdb for or1k documents for more info.",
2285 
                  &htrace_cmdlist, "htrace ", 0, &cmdlist);
2286 
  add_cmd ("info", class_breakpoint, htrace_info_command, "Display information about HW trace.",
2287 
           &htrace_cmdlist);
2288 
  add_alias_cmd ("i", "info", class_breakpoint, 1, &htrace_cmdlist);
2289 
  add_cmd ("trigger", class_breakpoint, htrace_trigger_command, "Set starting criteria for trace.",
2290 
           &htrace_cmdlist);
2291 
  add_alias_cmd ("t", "trigger", class_breakpoint, 1, &htrace_cmdlist);
2292 
  add_cmd ("qualifier", class_breakpoint, htrace_qualifier_command, "Set acquisition qualifier for HW trace.",
2293 
           &htrace_cmdlist);
2294 
  add_alias_cmd ("q", "qualifier", class_breakpoint, 1, &htrace_cmdlist);
2295 
  add_cmd ("stop", class_breakpoint, htrace_stop_command, "Set HW trace stopping criteria.",
2296 
           &htrace_cmdlist);
2297 
  add_alias_cmd ("s", "stop", class_breakpoint, 1, &htrace_cmdlist);
2298 
  add_cmd ("record", class_breakpoint, htrace_record_command, "Sets data to be recorded when expression occurs.",
2299 
           &htrace_cmdlist);
2300 
  add_alias_cmd ("r", "record", class_breakpoint, 1, &htrace_cmdlist);
2301 
  add_cmd ("clear records", class_breakpoint, htrace_clear_records_command,
2302 
           "Disposes all matchpoints used by records.", &htrace_cmdlist);
2303 
  add_cmd ("enable", class_breakpoint, htrace_enable_command, "Enables the HW trace.", &htrace_cmdlist);
2304 
  add_alias_cmd ("e", "enable", class_breakpoint, 1, &htrace_cmdlist);
2305 
  add_cmd ("disable", class_breakpoint, htrace_disable_command, "Disables the HW trace.", &htrace_cmdlist);
2306 
  add_alias_cmd ("d", "disable", class_breakpoint, 1, &htrace_cmdlist);
2307 
  add_cmd ("rewind", class_breakpoint, htrace_rewind_command, "Clears currently recorded trace data.\n"
2308 
           "If filename is specified, new trace file is made and any newly collected data\n"
2309 
           "will be written there.", &htrace_cmdlist);
2310 
  add_cmd ("print", class_breakpoint, htrace_print_command,
2311 
           "Prints trace buffer, using current record configuration.\n"
2312 
           "htrace print [<start> [<len>]]\n"
2313 
           "htrace print"
2314 
           , &htrace_cmdlist);
2315 
  add_alias_cmd ("p", "print", class_breakpoint, 1, &htrace_cmdlist);
2316 
  add_prefix_cmd ("mode", class_breakpoint, htrace_mode_command,
2317 
           "Configures the HW trace.\n"
2318 
           "htrace mode [continuous|suspend]"
2319 
           , &htrace_mode_cmdlist, "htrace mode ", 0, &htrace_cmdlist);
2320 
  add_alias_cmd ("m", "mode", class_breakpoint, 1, &htrace_cmdlist);
2321 
  add_cmd ("continuous", class_breakpoint, htrace_mode_contin_command,
2322 
           "Set continuous trace mode.\n", &htrace_mode_cmdlist);
2323 
  add_cmd ("suspend", class_breakpoint, htrace_mode_suspend_command,
2324 
           "Set suspend trace mode.\n", &htrace_mode_cmdlist);
2325 
 
2326 
  /* Extra functions supported by simulator.  */
2327 
  add_com ("sim", class_obscure, sim_command,
2328 
           "Send a extended command to the simulator.");
2329 
}
2330 372 markom 
 

powered by: WebSVN 2.1.0

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