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 115

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 
  printf_filtered (inv1 ? " %-5s flt: <invalid float>" :
309 
                       " %-5s flt:%-17.9g", REGISTER_NAME (regnum), flt);
310 
  printf_filtered (inv3 ? " dbl: <invalid double> " :
311 
                   " dbl: %-24.17g ", doub);
312 
 
313 
  /* pad small registers */
314 
  for (byte = 0; byte < (OR1K_GPR_REGSIZE - REGISTER_VIRTUAL_SIZE (regnum)); byte++)
315 
    printf_filtered ("  ");
316 
  /* Now print the register value in hex, endian order. */
317 
  if (TARGET_BYTE_ORDER == BIG_ENDIAN)
318 
    for (byte = REGISTER_RAW_SIZE (regnum) - REGISTER_VIRTUAL_SIZE (regnum);
319 
         byte < REGISTER_RAW_SIZE (regnum);
320 
         byte++)
321 
      printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
322 
  else
323 
    for (byte = REGISTER_VIRTUAL_SIZE (regnum) - 1;
324 
         byte >= 0;
325 
         byte--)
326 
      printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
327 
  printf_filtered ("\n");
328 
 
329 
  regnum++;
330 
  return regnum;
331 
}
332 
 
333 
/* Print a row's worth of GP (int) registers, with name labels above */
334 
 
335 
static int
336 
do_gp_register_row (regnum)
337 
     int regnum;
338 
{
339 
  /* do values for GP (int) regs */
340 
  char raw_buffer[MAX_REGISTER_RAW_SIZE];
341 
  int ncols = (OR1K_64BIT_IMPLEMENTATION ? 4 : 8);      /* display cols per row */
342 
  int col, byte;
343 
  int start_regnum = regnum;
344 
  int numregs = NUM_REGS;
345 
 
346 
 
347 
  /* For GP registers, we print a separate row of names above the vals */
348 
  printf_filtered ("     ");
349 
  for (col = 0; col < ncols && regnum < numregs; regnum++)
350 
    {
351 
      if (*REGISTER_NAME (regnum) == '\0')
352 
        continue;               /* unused register */
353 
      if (OR1K_IS_VF(regnum))
354 
        break;                  /* end the row: reached VF register */
355 
      printf_filtered (OR1K_64BIT_IMPLEMENTATION ? "%17s" : "%9s",
356 
                       REGISTER_NAME (regnum));
357 
      col++;
358 
    }
359 
  printf_filtered ("\n      ");
360 
 
361 
  regnum = start_regnum;        /* go back to start of row */
362 
 
363 
  /* now print the values in hex, 4 or 8 to the row */
364 
  for (col = 0; col < ncols && regnum < numregs; regnum++)
365 
    {
366 
      if (*REGISTER_NAME (regnum) == '\0')
367 
        continue;               /* unused register */
368 
      if (OR1K_IS_VF(regnum))
369 
        break;                  /* end row: reached VF register */
370 
      /* OK: get the data in raw format.  */
371 
      if (read_relative_register_raw_bytes (regnum, raw_buffer))
372 
        error ("can't read register %d (%s)", regnum, REGISTER_NAME (regnum));
373 
      /* pad small registers */
374 
      for (byte = 0; byte < (OR1K_GPR_REGSIZE - REGISTER_VIRTUAL_SIZE (regnum)); byte++)
375 
        printf_filtered ("  ");
376 
      /* Now print the register value in hex, endian order. */
377 
      if (TARGET_BYTE_ORDER == BIG_ENDIAN)
378 
        for (byte = REGISTER_RAW_SIZE (regnum) - REGISTER_VIRTUAL_SIZE (regnum);
379 
             byte < REGISTER_RAW_SIZE (regnum);
380 
             byte++)
381 
          printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
382 
      else
383 
        for (byte = REGISTER_VIRTUAL_SIZE (regnum) - 1;
384 
             byte >= 0;
385 
             byte--)
386 
          printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
387 
      printf_filtered (" ");
388 
      col++;
389 
    }
390 
  if (col > 0)                   /* ie. if we actually printed anything... */
391 
    printf_filtered ("\n");
392 
 
393 
  return regnum;
394 
}
395 
 
396 
/* Replacement for generic do_registers_info.
397 
   Print regs in pretty columns.  */
398 
static void
399 
print_register (regnum, all)
400 
     int regnum, all;
401 
{
402 
  int offset;
403 
  char raw_buffer[MAX_REGISTER_RAW_SIZE];
404 
 
405 
  /* Get the data in raw format.  */
406 
  if (read_relative_register_raw_bytes (regnum, raw_buffer))
407 
    {
408 
      printf_filtered ("%s: [Invalid]", REGISTER_NAME (regnum));
409 
      return;
410 
    }
411 
 
412 
  /* If virtual format is floating, print it that way.  */
413 
  if (OR1K_IS_VF (regnum))
414 
    do_vf_register (regnum);
415 
  else
416 
    {
417 
      int byte;
418 
      printf_filtered ("%-16s\t", REGISTER_NAME (regnum));
419 
 
420 
      /* pad small registers */
421 
      for (byte = 0; byte < (OR1K_GPR_REGSIZE - REGISTER_VIRTUAL_SIZE (regnum)); byte++)
422 
        printf_filtered ("  ");
423 
      /* Now print the register value in hex, endian order. */
424 
      if (TARGET_BYTE_ORDER == BIG_ENDIAN)
425 
        for (byte = REGISTER_RAW_SIZE (regnum) - REGISTER_VIRTUAL_SIZE (regnum);
426 
             byte < REGISTER_RAW_SIZE (regnum);
427 
             byte++)
428 
          printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
429 
      else
430 
        for (byte = REGISTER_VIRTUAL_SIZE (regnum) - 1;
431 
             byte >= 0;
432 
             byte--)
433 
          printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
434 
      printf_filtered (" ");
435 
    }
436 
}
437 
 
438 
/* DO_REGISTERS_INFO: called by "info register" command */
439 
 
440 
void
441 
or1k_do_registers_info (regnum, fpregs)
442 
     int regnum;
443 
     int fpregs;
444 
{
445 
  if (fpregs && !or1k_implementation.vf_present)
446 
    {
447 
      warning ("VF register set not present in this implementation.");
448 
      fpregs = 0;
449 
    }
450 
  if (regnum != -1)             /* do one specified register */
451 
    {
452 
      if (*(REGISTER_NAME (regnum)) == '\0')
453 
        error ("Not a valid register for the current processor type");
454 
 
455 
      print_register (regnum, 0);
456 
      printf_filtered ("\n");
457 
    }
458 
  else
459 
    /* do all (or most) registers */
460 
    {
461 
      regnum = 0;
462 
      while (regnum < NUM_REGS)
463 
        {
464 
          if (OR1K_IS_VF (regnum))
465 
            if (fpregs)         /* true for "INFO ALL-REGISTERS" command */
466 
              regnum = do_vf_register (regnum); /* FP regs */
467 
            else
468 
              regnum++;         /* skip floating point regs */
469 
          else
470 
            regnum = do_gp_register_row (regnum);       /* GP (int) regs */
471 
        }
472 
    }
473 
}
474 
 
475 104 markom 
/* Given the address at which to insert a breakpoint (BP_ADDR),
476 
   what will that breakpoint be?
477 
 
478 
   For or1k, we have a breakpoint instruction. Since all or1k
479 
   instructions are 32 bits, this is all we need, regardless of
480 
   address. K is not used.  */
481 
 
482 
unsigned char *
483 
or1k_breakpoint_from_pc (bp_addr, bp_size)
484 
     CORE_ADDR * bp_addr;
485 
     int *bp_size;
486 
{
487 113 markom 
  static char breakpoint[] = BRK_INSTR_STRUCT;
488 104 markom 
  *bp_size = OR1K_INSTLEN;
489 
  return breakpoint;
490 
}
491 
 
492 113 markom 
/* Return the string for a signal.  Replacement for target_signal_to_string (sig).  */
493 
char
494 
*or1k_signal_to_string (sig)
495 
     enum target_signal sig;
496 
{
497 
  if ((sig >= TARGET_SIGNAL_FIRST) && (sig <= TARGET_SIGNAL_LAST))
498 
    return or1k_signals[sig].string;
499 
  else
500 
    if (sig <= TARGET_SIGNAL_LAST + NUM_OR1K_SIGNALS)
501 
      return or1k_signals[sig - TARGET_SIGNAL_LAST].string;
502 
    else
503 
      return 0/* signals[TARGET_SIGNAL_UNKNOWN].string*/;
504 
}
505 
 
506 
/* Return the name for a signal.  */
507 
char *
508 
or1k_signal_to_name (sig)
509 
     enum target_signal sig;
510 
{
511 
  if (sig >= TARGET_SIGNAL_LAST)
512 
    if (sig <= TARGET_SIGNAL_LAST + NUM_OR1K_SIGNALS)
513 
      return or1k_signals[sig - TARGET_SIGNAL_LAST].name;
514 
    else
515 
    /* I think the code which prints this will always print it along with
516 
       the string, so no need to be verbose.  */
517 
      return "?";
518 
  if (sig == TARGET_SIGNAL_UNKNOWN)
519 
    return "?";
520 
  return 0/*!!!signals[sig].name*/;
521 
}
522 
 
523 
/* Given a name, return its signal.  */
524 
enum target_signal
525 
or1k_signal_from_name (name)
526 
     char *name;
527 
{
528 
  enum target_signal sig;
529 
 
530 
  /* It's possible we also should allow "SIGCLD" as well as "SIGCHLD"
531 
     for TARGET_SIGNAL_SIGCHLD.  SIGIOT, on the other hand, is more
532 
     questionable; seems like by now people should call it SIGABRT
533 
     instead.  */
534 
 
535 
  /* This ugly cast brought to you by the native VAX compiler.  */
536 
  for (sig = TARGET_SIGNAL_FIRST;
537 
       or1k_signal_to_name (sig) != NULL;
538 
       sig = (enum target_signal) ((int) sig + 1))
539 
    if (STREQ (name, or1k_signal_to_name (sig)))
540 
      return sig;
541 
  return TARGET_SIGNAL_UNKNOWN;
542 
}
543 
 
544 104 markom 
/* Given a return value in `regbuf' with a type `valtype', extract and
545 
   copy its value into `valbuf'. */
546 
void
547 
or1k_extract_return_value (valtype, regbuf, valbuf)
548 
     struct type *valtype;
549 
     char regbuf[REGISTER_BYTES];
550 
     char *valbuf;
551 
{
552 
  if (TYPE_CODE_FLT == TYPE_CODE (valtype))
553 
    memcpy (valbuf, &regbuf[REGISTER_BYTE (VFRV_REGNUM)], TYPE_LENGTH (valtype));
554 
  else
555 
    memcpy (valbuf, &regbuf[REGISTER_BYTE (RV_REGNUM)], TYPE_LENGTH (valtype));
556 
}
557 
 
558 
/* The or1k cc defines the following
559 
   prologue:
560 
00000000 <_proc1>:
561 
   0:   d7 e1 17 e4     l.sw 0xffffffe4(r1),r2
562 
   4:   9c 41 00 00     l.addi r2,r1,0x0
563 
   8:   9c 21 ff e8     l.addi r1,r1,0xffffffe8
564 
   c:   d7 e2 1f f8     l.sw 0xfffffff8(r2),r3
565 
  10:   d7 e2 27 f4     l.sw 0xfffffff4(r2),r4
566 
  14:   84 82 ff f8     l.lwz r4,0xfffffff8(r2)
567 
  18:   9d 24 00 00     l.addi r9,r4,0x0
568 
  1c:   00 00 00 02     l.j 0x2
569 
  20:   15 00 00 00     l.nop
570 
 
571 
00000024 <_L2>:
572 
  24:   84 41 ff fc     l.lwz r2,0xfffffffc(r1)
573 
  28:   48 00 58 00     l.jalr r11
574 
  2c:   9c 21 00 18     l.addi r1,r1,0x18 */
575 
 
576 
CORE_ADDR
577 
or1k_skip_prologue (CORE_ADDR pc)
578 
{
579 
  unsigned long inst;
580 
  CORE_ADDR skip_pc;
581 
  CORE_ADDR func_addr, func_end;
582 
  struct symtab_and_line sal;
583 
  int i;
584 
  int offset = 0;
585 
 
586 
  for (i = 0; i < MAX_GPR_REGS; i++)
587 
    or1k_saved_reg_addr[i] = -1;
588 
 
589 
  /* Is there a prologue?  */
590 
  inst = or1k_fetch_instruction (pc);
591 
  if (inst & 0xfc1ff800 != 0xd4011000) return pc; /* l.sw I(r1),r2 */
592 
  or1k_saved_reg_addr[2] = offset++;
593 
  inst = or1k_fetch_instruction (pc + OR1K_INSTLEN);
594 
  if (inst & 0xFFFF0000 != 0x9c410000) return pc; /* l.addi r2,r1,I */
595 
  pc += 2 * OR1K_INSTLEN;
596 
  inst = or1k_fetch_instruction (pc);
597 
  if (inst & 0xFFFF0000 != 0x9c210000) return pc; /* l.addi r1,r1,I */
598 
  pc += OR1K_INSTLEN;
599 
 
600 
  /* Skip stored registers.  */
601 
  inst = or1k_fetch_instruction (pc);
602 
  while (inst & 0xfc1ff800 != 0xd4020000)         /* l.sw 0x0(r2),rx */
603 
    {
604 
      /* get saved reg. */
605 
      or1k_saved_reg_addr[(inst >> 11) & 0x1f] = offset++;
606 
      pc += OR1K_INSTLEN;
607 
      inst = or1k_fetch_instruction (pc);
608 
    }
609 
  return pc;
610 
}
611 
 
612 
/* Determines whether this function has frame.  */
613 
 
614 
int
615 
or1k_frameless_function_invocation (struct frame_info *fi)
616 
{
617 
  CORE_ADDR func_start, after_prologue;
618 
  int frameless;
619 
  func_start = (get_pc_function_start ((fi)->pc) + FUNCTION_START_OFFSET);
620 
  after_prologue = SKIP_PROLOGUE (func_start);
621 
 
622 
  /* If we don't skip pc, we don't have even shortest possible  prologue.  */
623 
  frameless = (after_prologue <= func_start);
624 
  return frameless;
625 
}
626 
 
627 
/* Given a GDB frame, determine the address of the calling function's frame.
628 
   This will be used to create a new GDB frame struct, and then
629 
   INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame. */
630 
 
631 
CORE_ADDR
632 
or1k_frame_chain (frame)
633 
     struct frame_info *frame;
634 
{
635 
  CORE_ADDR fp;
636 
  if (USE_GENERIC_DUMMY_FRAMES)
637 
    {
638 
      if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
639 
        return frame->frame;    /* dummy frame same as caller's frame */
640 
    }
641 
 
642 
  if (inside_entry_file (frame->pc) ||
643 
      frame->pc == entry_point_address ())
644 
    return 0;
645 
 
646 
  if (frame->signal_handler_caller)
647 
    fp = read_memory_integer (frame->frame, 4);
648 
  else if (frame->next != NULL
649 
           && frame->next->signal_handler_caller
650 
           && FRAMELESS_FUNCTION_INVOCATION (frame))
651 
    /* A frameless function interrupted by a signal did not change the
652 
       frame pointer.  */
653 
    fp = FRAME_FP (frame);
654 
  else
655 
    fp = read_memory_integer (frame->frame, 4);
656 
 
657 
  if (USE_GENERIC_DUMMY_FRAMES)
658 
    {
659 
      CORE_ADDR fpp, lr;
660 
 
661 
      lr = read_register (LR_REGNUM);
662 
      if (lr == entry_point_address ())
663 
        if (fp != 0 && (fpp = read_memory_integer (fp, 4)) != 0)
664 
          if (PC_IN_CALL_DUMMY (lr, fpp, fpp))
665 
            return fpp;
666 
    }
667 
 
668 
  return fp;
669 
}
670 
 
671 
/* The code to store, into a struct frame_saved_regs,
672 
   the addresses of the saved registers of frame described by FRAME_INFO.
673 
   This includes special registers such as pc and fp saved in special
674 
   ways in the stack frame.  sp is even more special:
675 
   the address we return for it IS the sp for the next frame.  */
676 
void
677 
or1k_init_saved_regs (struct frame_info *fi)
678 
{
679 
  CORE_ADDR frame_addr;
680 
  int i;
681 
  frame_saved_regs_zalloc (fi);
682 
 
683 
  /* Skip prologue sets or1k_saved_reg_addr[], we will use it later.  */
684 
  or1k_skip_prologue (get_pc_function_start ((fi)->pc) + FUNCTION_START_OFFSET);
685 
 
686 
  for (i = 0; i < NUM_GPR_REGS+NUM_VF_REGS; i++)
687 
    if (or1k_saved_reg_addr[i] >= 0)
688 
      fi->saved_regs[i] = fi->frame + or1k_saved_reg_addr[i];
689 
}
690 
 
691 
 
692 
static CORE_ADDR
693 
read_next_frame_reg (fi, regno)
694 
     struct frame_info *fi;
695 
     int regno;
696 
{
697 
  for (; fi; fi = fi->next)
698 
    {
699 
      /* We have to get the saved sp from the sigcontext
700 
         if it is a signal handler frame.  */
701 
      if (regno == SP_REGNUM && !fi->signal_handler_caller)
702 
        return fi->frame;
703 
      else
704 
        {
705 
          if (fi->saved_regs == NULL)
706 
            or1k_init_saved_regs (fi);
707 
          if (fi->saved_regs[regno])
708 
            return read_memory_integer (ADDR_BITS_REMOVE (fi->saved_regs[regno]), OR1K_GPR_REGSIZE);
709 
        }
710 
    }
711 
  return read_register (regno);
712 
}
713 
 
714 
/* Find the caller of this frame.  We do this by seeing if LR_REGNUM
715 
   is saved in the stack anywhere, otherwise we get it from the
716 
   registers.  */
717 
 
718 
CORE_ADDR
719 
or1k_frame_saved_pc (fi)
720 
     struct frame_info *fi;
721 
{
722 
  CORE_ADDR saved_pc;
723 
  /* We have to get the saved pc from the sigcontext
724 
     if it is a signal handler frame.  */
725 
  if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
726 
    saved_pc = read_memory_integer (fi->frame, OR1K_GPR_REGSIZE);
727 
  else
728 
    saved_pc = read_next_frame_reg (fi, PC_REGNUM);
729 
 
730 
  return ADDR_BITS_REMOVE (saved_pc);
731 
}
732 
 
733 
/* Discard from the stack the innermost frame, restoring all registers.  */
734 
 
735 
void
736 
or1k_pop_frame ()
737 
{
738 
  register int regnum;
739 
  struct frame_info *frame = get_current_frame ();
740 
  CORE_ADDR new_sp = FRAME_FP (frame);
741 
 
742 
  write_register (PC_REGNUM, FRAME_SAVED_PC (frame));
743 
  if (frame->saved_regs == NULL)
744 
    or1k_init_saved_regs (frame);
745 
  for (regnum = 0; regnum < NUM_REGS; regnum++)    {
746 
      if (regnum != SP_REGNUM && regnum != PC_REGNUM
747 
          && frame->saved_regs[regnum] >= 0)
748 
        write_register (regnum,
749 
                        read_memory_integer (frame->saved_regs[regnum],
750 
                                             OR1K_GPR_REGSIZE));
751 
    }
752 
  write_register (SP_REGNUM, new_sp);
753 
  flush_cached_frames ();
754 
}
755 
 
756 
CORE_ADDR
757 
or1k_push_arguments (nargs, args, sp, struct_return, struct_addr)
758 
     int nargs;
759 
     value_ptr *args;
760 
     CORE_ADDR sp;
761 
     int struct_return;
762 
     CORE_ADDR struct_addr;
763 
{
764 
  int argreg;
765 
  int float_argreg;
766 
  int argnum;
767 
  int len = 0;
768 
  int stack_offset = 0;
769 
 
770 
  /* Initialize the integer and float register pointers.  */
771 
  argreg = A0_REGNUM;
772 
  float_argreg = VFA0_REGNUM;
773 
 
774 
  /* The struct_return pointer occupies the RV value register.  */
775 
  if (struct_return)
776 
    write_register (RV_REGNUM, struct_addr);
777 
 
778 
  /* Now load as many as possible of the first arguments into
779 
     registers, and push the rest onto the stack.  Loop thru args
780 
     from first to last.  */
781 
  for (argnum = 0; argnum < nargs; argnum++)
782 
    {
783 
      char *val;
784 
      char valbuf[MAX_REGISTER_RAW_SIZE];
785 
      value_ptr arg = args[argnum];
786 
      struct type *arg_type = check_typedef (VALUE_TYPE (arg));
787 
      int len = TYPE_LENGTH (arg_type);
788 
      enum type_code typecode = TYPE_CODE (arg_type);
789 
 
790 
      /* The EABI passes structures that do not fit in a register by
791 
         reference. In all other cases, pass the structure by value.  */
792 
      if (len > OR1K_GPR_REGSIZE &&
793 
          (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION))
794 
        {
795 
          store_address (valbuf, OR1K_GPR_REGSIZE, VALUE_ADDRESS (arg));
796 
          typecode = TYPE_CODE_PTR;
797 
          len = OR1K_GPR_REGSIZE;
798 
          val = valbuf;
799 
        }
800 
      else
801 
        {
802 
          val = (char *) VALUE_CONTENTS (arg);
803 
 
804 
          if (typecode == TYPE_CODE_FLT
805 
              /* Doubles are not stored in regs on 32b target.  */
806 
              && len <= OR1K_VF_REGSIZE
807 
              && OR1K_VF_PRESENT)
808 
            {
809 
              if (float_argreg <= OR1K_LAST_FP_ARG_REGNUM)
810 
                {
811 
                  CORE_ADDR regval = extract_address (val, len);
812 
                  write_register (float_argreg++, regval);
813 
                }
814 
              else
815 
                {
816 
                  write_memory ((CORE_ADDR) sp, val, OR1K_VF_REGSIZE);
817 
                  sp -= OR1K_STACK_ALIGN;
818 
                }
819 
            }
820 
          else
821 
            {
822 
              if (argreg <= OR1K_LAST_ARG_REGNUM)
823 
                {
824 
                  CORE_ADDR regval = extract_address (val, len);
825 
                  write_register (argreg++, regval);
826 
                }
827 
              else
828 
                {
829 
                  write_memory ((CORE_ADDR) sp, val, OR1K_GPR_REGSIZE);
830 
                  sp -= OR1K_STACK_ALIGN;
831 
                }
832 
            }
833 
        }
834 
    }
835 
 
836 
  /* Return adjusted stack pointer.  */
837 
  return sp;
838 
}
839 
 
840 
/* Return nonzero when instruction has delay slot.  */
841 
static int
842 
is_delayed (insn)
843 
     unsigned long insn;
844 
{
845 
  int i;
846 
  for (i = 0; i < num_opcodes; ++i)
847 
    if ((or32_opcodes[i].flags & OR32_IF_DELAY)
848 
        && (or32_opcode_match (insn, or32_opcodes[i].encoding)))
849 
      break;
850 
  return (i < num_opcodes);
851 
}
852 
 
853 
int
854 
or1k_step_skips_delay (pc)
855 
     CORE_ADDR pc;
856 
{
857 
  char buf[OR1K_INSTLEN];
858 
 
859 
  if (target_read_memory (pc, buf, OR1K_INSTLEN) != 0)
860 
    /* If error reading memory, guess that it is not a delayed branch.  */
861 
    return 0;
862 
  return is_delayed ((unsigned long) extract_unsigned_integer (buf, OR1K_INSTLEN));
863 
}
864 
 
865 
CORE_ADDR
866 
or1k_push_return_address (pc, sp)
867 
     CORE_ADDR pc;
868 
     CORE_ADDR sp;
869 
{
870 
  /* Set the return address register to point to the entry
871 
     point of the program, where a breakpoint lies in wait.  */
872 
  write_register (LR_REGNUM, CALL_DUMMY_ADDRESS ());
873 
  return sp;
874 
}
875 
 
876 
/* Root of all "set or1k "/"show or1k " commands. This will eventually be
877 
   used for all OR1K-specific commands.  */
878 
 
879 
static void show_or1k_command PARAMS ((char *, int));
880 
static void
881 
show_or1k_command (args, from_tty)
882 
     char *args;
883 
     int from_tty;
884 
{
885 
  help_list (showor1kcmdlist, "show or1k ", all_commands, gdb_stdout);
886 
}
887 
 
888 
static void set_or1k_command PARAMS ((char *, int));
889 
static void
890 
set_or1k_command (args, from_tty)
891 
     char *args;
892 
     int from_tty;
893 
{
894 
  printf_unfiltered ("\"set or1k\" must be followed by an appropriate subcommand.\n");
895 
  help_list (setor1kcmdlist, "set or1k ", all_commands, gdb_stdout);
896 
}
897 
 
898 115 markom 
/* Parses args for spr name and puts result into group and index.  */
899 
 
900 104 markom 
static char *
901 
parse_spr_params (args, group, index)
902 
                  char *args;
903 
                  int *group, *index;
904 
{
905 
  *index = -1;
906 
  if (args)
907 
    {
908 
      int i;
909 
      char *ptr_c;
910 
      /* Check if group number was supplied.  */
911 
      ptr_c = args;
912 
      while (*ptr_c != ' ' && *ptr_c != 0)
913 
        ptr_c++;
914 
      *ptr_c = 0;
915 
 
916 
      *group = (int) strtoul (args, &ptr_c, 0);
917 
      if (*ptr_c != 0)
918 
        {
919 
          *group = OR1K_NUM_SPR_GROUPS;
920 
          /* check for group name */
921 
          for (i = 0; i < OR1K_NUM_SPR_GROUPS; i++)
922 
            if (strcasecmp (or1k_group_names[i], args) == 0)
923 
              {
924 
                *group = i;
925 
                break;
926 
              }
927 
          /* Invalid group => check all register names in all groups.  */
928 
          if (*group >= OR1K_NUM_SPR_GROUPS)
929 
            {
930 
              for (i = 0; i < OR1K_NUM_SPR_GROUPS; i++)
931 
                {
932 
                  int regno;
933 
                  regno = or1k_regno_from_name (i, args);
934 
                  if (regno >= 0)
935 
                    {
936 
                      *group = i;
937 
                      *index = regno;
938 
                    }
939 
                }
940 
            }
941 
        }
942 
      if (*group < 0 || *group >= OR1K_NUM_SPR_GROUPS)
943 
        error ("Invalid group or register.\n");
944 
 
945 
      if (*index < 0)
946 
        {
947 
          args += strlen(args) + 1;
948 
          ptr_c = args;
949 
          while (*ptr_c != ' ' && *ptr_c != 0)
950 
            ptr_c++;
951 
          *ptr_c = 0;
952 
          *index = (int) strtoul (args, &ptr_c, 0);
953 
          if (*ptr_c != 0)
954 
            *index = or1k_regno_from_name (*group, args);
955 115 markom 
          else *index = -1;
956 104 markom 
 
957 
          if (*index < 0)
958 
            {
959 115 markom 
              printf_filtered ("No register supplied. Valid registers are:\n");
960 104 markom 
              for (i = 0; i < or1k_spr_valid_aliases[*group]; i++)
961 115 markom 
                {
962 
                  char reg_name[16];
963 
                  char *gen_name = or1k_spr_register_name (SPR_REG(*group, i));
964 
                  sprintf (reg_name, "SPR%i_%i", *group, i);
965 
                  if (strcmp (reg_name, gen_name) != 0)
966 
                    printf_filtered ("%s\t", gen_name);
967 
                }
968 
              printf_filtered ("\n");
969 104 markom 
              return args + strlen(args) + 1;
970 
            }
971 
        }
972 
    }
973 
  else
974 
  /* No parameters - print groups */
975 
    {
976 
      int i;
977 115 markom 
      printf_filtered ("No parameter supplied. Valid groups are:\n");
978 104 markom 
      for (i = 0; i < OR1K_NUM_SPR_GROUPS; i++)
979 115 markom 
        printf_filtered ("%s\t", or1k_group_names[i]);
980 
      printf_filtered ("\nSingle register name or register name or number after the group can be also supplied.\n");
981 
      return args;
982 104 markom 
    }
983 
  return args + strlen(args) + 1;
984 
}
985 
 
986 
/* SPR register info.  */
987 
 
988 
void
989 113 markom 
info_spr_command (char *args, int from_tty)
990 104 markom 
{
991 
  int group, index;
992 
  parse_spr_params (args, &group, &index);
993 
  if (index >= 0)
994 
    {
995 
      printf_unfiltered ("%s.%s (SPR%i_%i) set to %i(%X), was:%i(%X)\n", or1k_group_names[group],
996 113 markom 
                         or1k_spr_register_name (SPR_REG(group, index)), group, index,
997 
                         or1k_read_spr_reg (SPR_REG(group, index)));
998 104 markom 
    }
999 
}
1000 
 
1001 
/* Set SPR register.  */
1002 
 
1003 
void
1004 113 markom 
spr_command (char *args, int from_tty)
1005 104 markom 
{
1006 
  int group, index;
1007 
  char *nargs = parse_spr_params (args, &group, &index);
1008 
  if (index >= 0)
1009 
    {
1010 
      unsigned long prev;
1011 
      unsigned long value;
1012 
      char *ptr_c;
1013 
 
1014 115 markom 
      /* Any arguments left?  */
1015 
      if (args + strlen(args) >= nargs)
1016 
        error ("Invalid register value.");
1017 
 
1018 113 markom 
      prev = or1k_read_spr_reg (SPR_REG(group, index));
1019 104 markom 
 
1020 
      ptr_c = nargs;
1021 
      while (*ptr_c != ' ' && *ptr_c != 0)
1022 
        ptr_c++;
1023 
      *ptr_c = 0;
1024 
      value = strtoul (nargs, &ptr_c, 0);
1025 
      if (*ptr_c != 0)
1026 
        error ("Invalid register value.");
1027 
      printf_unfiltered ("%s.%s (SPR%i_%i) set to %i(%X), was:%i(%X)\n", or1k_group_names[group],
1028 113 markom 
                         or1k_spr_register_name (SPR_REG(group, index)), group, index,
1029 104 markom 
                         value, value, prev, prev);
1030 
    }
1031 
}
1032 
 
1033 
/* Calls extended command on target.  */
1034 
 
1035 
void
1036 
sim_command (char *args, int from_tty)
1037 
{
1038 
  or1k_sim_cmd (args, from_tty);
1039 
}
1040 
 
1041 113 markom 
/* ARGSUSED */
1042 
/* accessflag:  hw_write:  watch write,
1043 
                hw_read:   watch read,
1044 
                hw_access: watch access (read or write) */
1045 
static void
1046 
hwatch_command (arg, from_tty)
1047 
     char *arg;
1048 
     int from_tty;
1049 
{
1050 
  struct expression *exp;
1051 
  int i;
1052 
  int nfree;
1053 
  /* Parse arguments.  */
1054 
  exp = parse_exp_1 (&arg, 0, 0);
1055 
 
1056 
  dump_prefix_expression (exp, gdb_stdout, "expr1");
1057 
 
1058 
  /* Now we have to find out if given prefix expression matches
1059 
     our HW based support. It may take up to
1060 
     or1k_implementation.num_matchpoints - or1k_implementation.num_used_matchpoints. */
1061 
  nfree = or1k_implementation.num_matchpoints - or1k_implementation.num_used_matchpoints;
1062 
  //printf_unfiltered ("%s\n", exp->elts[1].internalvar->name);
1063 
  free (exp);
1064 
}
1065 
 
1066 104 markom 
void
1067 
_initialize_or1k_tdep ()
1068 
{
1069 
  struct cmd_list_element *c;
1070 
  /* Add root prefix command for all "set or1k"/"show or1k" commands */
1071 
  add_prefix_cmd ("or1k", no_class, set_or1k_command,
1072 
                  "Various OR1K specific commands.",
1073 
                  &setor1kcmdlist, "set or1k ", 0, &setlist);
1074 
 
1075 
  add_prefix_cmd ("or1k", no_class, show_or1k_command,
1076 
                  "Various OR1K specific commands.",
1077 
                  &showor1kcmdlist, "show or1k ", 0, &showlist);
1078 
 
1079 
  /* Commands to show information about the sprs.  */
1080 113 markom 
  add_info ("spr", info_spr_command, "Show information about the spr registers.");
1081 
  add_com ("hwatch", class_breakpoint, hwatch_command, "Set hardware watchpoint.");
1082 
  add_com ("spr", class_support, spr_command, "Set specified SPR register.");
1083 104 markom 
  add_com ("sim", class_obscure, sim_command,
1084 
           "Send a extended command to the simulator.");
1085 
}

powered by: WebSVN 2.1.0

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