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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [gdb/] [mt-tdep.c] - Blame information for rev 857

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

Line No. Rev Author Line
1 24 jeremybenn
/* Target-dependent code for Morpho mt processor, for GDB.
2
 
3
   Copyright (C) 2005, 2007, 2008 Free Software Foundation, Inc.
4
 
5
   This file is part of GDB.
6
 
7
   This program is free software; you can redistribute it and/or modify
8
   it under the terms of the GNU General Public License as published by
9
   the Free Software Foundation; either version 3 of the License, or
10
   (at your option) any later version.
11
 
12
   This program is distributed in the hope that it will be useful,
13
   but WITHOUT ANY WARRANTY; without even the implied warranty of
14
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
   GNU General Public License for more details.
16
 
17
   You should have received a copy of the GNU General Public License
18
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19
 
20
/* Contributed by Michael Snyder, msnyder@redhat.com.  */
21
 
22
#include "defs.h"
23
#include "frame.h"
24
#include "frame-unwind.h"
25
#include "frame-base.h"
26
#include "symtab.h"
27
#include "dis-asm.h"
28
#include "arch-utils.h"
29
#include "gdbtypes.h"
30
#include "gdb_string.h"
31
#include "regcache.h"
32
#include "reggroups.h"
33
#include "gdbcore.h"
34
#include "trad-frame.h"
35
#include "inferior.h"
36
#include "dwarf2-frame.h"
37
#include "infcall.h"
38
#include "gdb_assert.h"
39
 
40
enum mt_arch_constants
41
{
42
  MT_MAX_STRUCT_SIZE = 16
43
};
44
 
45
enum mt_gdb_regnums
46
{
47
  MT_R0_REGNUM,                 /* 32 bit regs.  */
48
  MT_R1_REGNUM,
49
  MT_1ST_ARGREG = MT_R1_REGNUM,
50
  MT_R2_REGNUM,
51
  MT_R3_REGNUM,
52
  MT_R4_REGNUM,
53
  MT_LAST_ARGREG = MT_R4_REGNUM,
54
  MT_R5_REGNUM,
55
  MT_R6_REGNUM,
56
  MT_R7_REGNUM,
57
  MT_R8_REGNUM,
58
  MT_R9_REGNUM,
59
  MT_R10_REGNUM,
60
  MT_R11_REGNUM,
61
  MT_R12_REGNUM,
62
  MT_FP_REGNUM = MT_R12_REGNUM,
63
  MT_R13_REGNUM,
64
  MT_SP_REGNUM = MT_R13_REGNUM,
65
  MT_R14_REGNUM,
66
  MT_RA_REGNUM = MT_R14_REGNUM,
67
  MT_R15_REGNUM,
68
  MT_IRA_REGNUM = MT_R15_REGNUM,
69
  MT_PC_REGNUM,
70
 
71
  /* Interrupt Enable pseudo-register, exported by SID.  */
72
  MT_INT_ENABLE_REGNUM,
73
  /* End of CPU regs.  */
74
 
75
  MT_NUM_CPU_REGS,
76
 
77
  /* Co-processor registers.  */
78
  MT_COPRO_REGNUM = MT_NUM_CPU_REGS,    /* 16 bit regs.  */
79
  MT_CPR0_REGNUM,
80
  MT_CPR1_REGNUM,
81
  MT_CPR2_REGNUM,
82
  MT_CPR3_REGNUM,
83
  MT_CPR4_REGNUM,
84
  MT_CPR5_REGNUM,
85
  MT_CPR6_REGNUM,
86
  MT_CPR7_REGNUM,
87
  MT_CPR8_REGNUM,
88
  MT_CPR9_REGNUM,
89
  MT_CPR10_REGNUM,
90
  MT_CPR11_REGNUM,
91
  MT_CPR12_REGNUM,
92
  MT_CPR13_REGNUM,
93
  MT_CPR14_REGNUM,
94
  MT_CPR15_REGNUM,
95
  MT_BYPA_REGNUM,               /* 32 bit regs.  */
96
  MT_BYPB_REGNUM,
97
  MT_BYPC_REGNUM,
98
  MT_FLAG_REGNUM,
99
  MT_CONTEXT_REGNUM,            /* 38 bits (treat as array of
100
                                   six bytes).  */
101
  MT_MAC_REGNUM,                        /* 32 bits.  */
102
  MT_Z1_REGNUM,                 /* 16 bits.  */
103
  MT_Z2_REGNUM,                 /* 16 bits.  */
104
  MT_ICHANNEL_REGNUM,           /* 32 bits.  */
105
  MT_ISCRAMB_REGNUM,            /* 32 bits.  */
106
  MT_QSCRAMB_REGNUM,            /* 32 bits.  */
107
  MT_OUT_REGNUM,                        /* 16 bits.  */
108
  MT_EXMAC_REGNUM,              /* 32 bits (8 used).  */
109
  MT_QCHANNEL_REGNUM,           /* 32 bits.  */
110
  MT_ZI2_REGNUM,                /* 16 bits.  */
111
  MT_ZQ2_REGNUM,                /* 16 bits.  */
112
  MT_CHANNEL2_REGNUM,           /* 32 bits.  */
113
  MT_ISCRAMB2_REGNUM,           /* 32 bits.  */
114
  MT_QSCRAMB2_REGNUM,           /* 32 bits.  */
115
  MT_QCHANNEL2_REGNUM,          /* 32 bits.  */
116
 
117
  /* Number of real registers.  */
118
  MT_NUM_REGS,
119
 
120
  /* Pseudo-registers.  */
121
  MT_COPRO_PSEUDOREG_REGNUM = MT_NUM_REGS,
122
  MT_MAC_PSEUDOREG_REGNUM,
123
  MT_COPRO_PSEUDOREG_ARRAY,
124
 
125
  MT_COPRO_PSEUDOREG_DIM_1 = 2,
126
  MT_COPRO_PSEUDOREG_DIM_2 = 8,
127
  /* The number of pseudo-registers for each coprocessor.  These
128
     include the real coprocessor registers, the pseudo-registe for
129
     the coprocessor number, and the pseudo-register for the MAC.  */
130
  MT_COPRO_PSEUDOREG_REGS = MT_NUM_REGS - MT_NUM_CPU_REGS + 2,
131
  /* The register number of the MAC, relative to a given coprocessor.  */
132
  MT_COPRO_PSEUDOREG_MAC_REGNUM = MT_COPRO_PSEUDOREG_REGS - 1,
133
 
134
  /* Two pseudo-regs ('coprocessor' and 'mac').  */
135
  MT_NUM_PSEUDO_REGS = 2 + (MT_COPRO_PSEUDOREG_REGS
136
                            * MT_COPRO_PSEUDOREG_DIM_1
137
                            * MT_COPRO_PSEUDOREG_DIM_2)
138
};
139
 
140
/* Return name of register number specified by REGNUM.  */
141
 
142
static const char *
143
mt_register_name (struct gdbarch *gdbarch, int regnum)
144
{
145
  static const char *const register_names[] = {
146
    /* CPU regs.  */
147
    "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
148
    "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
149
    "pc", "IE",
150
    /* Co-processor regs.  */
151
    "",                         /* copro register.  */
152
    "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
153
    "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
154
    "bypa", "bypb", "bypc", "flag", "context", "" /* mac.  */ , "z1", "z2",
155
    "Ichannel", "Iscramb", "Qscramb", "out", "" /* ex-mac.  */ , "Qchannel",
156
    "zi2", "zq2", "Ichannel2", "Iscramb2", "Qscramb2", "Qchannel2",
157
    /* Pseudo-registers.  */
158
    "coprocessor", "MAC"
159
  };
160
  static const char *array_names[MT_COPRO_PSEUDOREG_REGS
161
                                 * MT_COPRO_PSEUDOREG_DIM_1
162
                                 * MT_COPRO_PSEUDOREG_DIM_2];
163
 
164
  if (regnum < 0)
165
    return "";
166
  if (regnum < ARRAY_SIZE (register_names))
167
    return register_names[regnum];
168
  if (array_names[regnum - MT_COPRO_PSEUDOREG_ARRAY])
169
    return array_names[regnum - MT_COPRO_PSEUDOREG_ARRAY];
170
 
171
  {
172
    char *name;
173
    const char *stub;
174
    unsigned dim_1;
175
    unsigned dim_2;
176
    unsigned index;
177
 
178
    regnum -= MT_COPRO_PSEUDOREG_ARRAY;
179
    index = regnum % MT_COPRO_PSEUDOREG_REGS;
180
    dim_2 = (regnum / MT_COPRO_PSEUDOREG_REGS) % MT_COPRO_PSEUDOREG_DIM_2;
181
    dim_1 = ((regnum / MT_COPRO_PSEUDOREG_REGS / MT_COPRO_PSEUDOREG_DIM_2)
182
             %  MT_COPRO_PSEUDOREG_DIM_1);
183
 
184
    if (index == MT_COPRO_PSEUDOREG_MAC_REGNUM)
185
      stub = register_names[MT_MAC_PSEUDOREG_REGNUM];
186
    else if (index >= MT_NUM_REGS - MT_CPR0_REGNUM)
187
      stub = "";
188
    else
189
      stub = register_names[index + MT_CPR0_REGNUM];
190
    if (!*stub)
191
      {
192
        array_names[regnum] = stub;
193
        return stub;
194
      }
195
    name = xmalloc (30);
196
    sprintf (name, "copro_%d_%d_%s", dim_1, dim_2, stub);
197
    array_names[regnum] = name;
198
    return name;
199
  }
200
}
201
 
202
/* Return the type of a coprocessor register.  */
203
 
204
static struct type *
205
mt_copro_register_type (struct gdbarch *arch, int regnum)
206
{
207
  switch (regnum)
208
    {
209
    case MT_INT_ENABLE_REGNUM:
210
    case MT_ICHANNEL_REGNUM:
211
    case MT_QCHANNEL_REGNUM:
212
    case MT_ISCRAMB_REGNUM:
213
    case MT_QSCRAMB_REGNUM:
214
      return builtin_type_int32;
215
    case MT_BYPA_REGNUM:
216
    case MT_BYPB_REGNUM:
217
    case MT_BYPC_REGNUM:
218
    case MT_Z1_REGNUM:
219
    case MT_Z2_REGNUM:
220
    case MT_OUT_REGNUM:
221
    case MT_ZI2_REGNUM:
222
    case MT_ZQ2_REGNUM:
223
      return builtin_type_int16;
224
    case MT_EXMAC_REGNUM:
225
    case MT_MAC_REGNUM:
226
      return builtin_type_uint32;
227
    case MT_CONTEXT_REGNUM:
228
      return builtin_type_long_long;
229
    case MT_FLAG_REGNUM:
230
      return builtin_type_unsigned_char;
231
    default:
232
      if (regnum >= MT_CPR0_REGNUM && regnum <= MT_CPR15_REGNUM)
233
        return builtin_type_int16;
234
      else if (regnum == MT_CPR0_REGNUM + MT_COPRO_PSEUDOREG_MAC_REGNUM)
235
        {
236
          if (gdbarch_bfd_arch_info (arch)->mach == bfd_mach_mrisc2
237
              || gdbarch_bfd_arch_info (arch)->mach == bfd_mach_ms2)
238
            return builtin_type_uint64;
239
          else
240
            return builtin_type_uint32;
241
        }
242
      else
243
        return builtin_type_uint32;
244
    }
245
}
246
 
247
/* Given ARCH and a register number specified by REGNUM, return the
248
   type of that register.  */
249
 
250
static struct type *
251
mt_register_type (struct gdbarch *arch, int regnum)
252
{
253
  static struct type *void_func_ptr = NULL;
254
  static struct type *void_ptr = NULL;
255
  static struct type *copro_type;
256
 
257
  if (regnum >= 0 && regnum < MT_NUM_REGS + MT_NUM_PSEUDO_REGS)
258
    {
259
      if (void_func_ptr == NULL)
260
        {
261
          struct type *temp;
262
 
263
          void_ptr = lookup_pointer_type (builtin_type_void);
264
          void_func_ptr =
265
            lookup_pointer_type (lookup_function_type (builtin_type_void));
266
          temp = create_range_type (NULL, builtin_type_unsigned_int, 0, 1);
267
          copro_type = create_array_type (NULL, builtin_type_int16, temp);
268
        }
269
      switch (regnum)
270
        {
271
        case MT_PC_REGNUM:
272
        case MT_RA_REGNUM:
273
        case MT_IRA_REGNUM:
274
          return void_func_ptr;
275
        case MT_SP_REGNUM:
276
        case MT_FP_REGNUM:
277
          return void_ptr;
278
        case MT_COPRO_REGNUM:
279
        case MT_COPRO_PSEUDOREG_REGNUM:
280
          return copro_type;
281
        case MT_MAC_PSEUDOREG_REGNUM:
282
          return mt_copro_register_type (arch,
283
                                         MT_CPR0_REGNUM
284
                                         + MT_COPRO_PSEUDOREG_MAC_REGNUM);
285
        default:
286
          if (regnum >= MT_R0_REGNUM && regnum <= MT_R15_REGNUM)
287
            return builtin_type_int32;
288
          else if (regnum < MT_COPRO_PSEUDOREG_ARRAY)
289
            return mt_copro_register_type (arch, regnum);
290
          else
291
            {
292
              regnum -= MT_COPRO_PSEUDOREG_ARRAY;
293
              regnum %= MT_COPRO_PSEUDOREG_REGS;
294
              regnum += MT_CPR0_REGNUM;
295
              return mt_copro_register_type (arch, regnum);
296
            }
297
        }
298
    }
299
  internal_error (__FILE__, __LINE__,
300
                  _("mt_register_type: illegal register number %d"), regnum);
301
}
302
 
303
/* Return true if register REGNUM is a member of the register group
304
   specified by GROUP.  */
305
 
306
static int
307
mt_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
308
                         struct reggroup *group)
309
{
310
  /* Groups of registers that can be displayed via "info reg".  */
311
  if (group == all_reggroup)
312
    return (regnum >= 0
313
            && regnum < MT_NUM_REGS + MT_NUM_PSEUDO_REGS
314
            && mt_register_name (gdbarch, regnum)[0] != '\0');
315
 
316
  if (group == general_reggroup)
317
    return (regnum >= MT_R0_REGNUM && regnum <= MT_R15_REGNUM);
318
 
319
  if (group == float_reggroup)
320
    return 0;                    /* No float regs.  */
321
 
322
  if (group == vector_reggroup)
323
    return 0;                    /* No vector regs.  */
324
 
325
  /* For any that are not handled above.  */
326
  return default_register_reggroup_p (gdbarch, regnum, group);
327
}
328
 
329
/* Return the return value convention used for a given type TYPE.
330
   Optionally, fetch or set the return value via READBUF or
331
   WRITEBUF respectively using REGCACHE for the register
332
   values.  */
333
 
334
static enum return_value_convention
335
mt_return_value (struct gdbarch *gdbarch, struct type *type,
336
                  struct regcache *regcache, gdb_byte *readbuf,
337
                  const gdb_byte *writebuf)
338
{
339
  if (TYPE_LENGTH (type) > 4)
340
    {
341
      /* Return values > 4 bytes are returned in memory,
342
         pointed to by R11.  */
343
      if (readbuf)
344
        {
345
          ULONGEST addr;
346
 
347
          regcache_cooked_read_unsigned (regcache, MT_R11_REGNUM, &addr);
348
          read_memory (addr, readbuf, TYPE_LENGTH (type));
349
        }
350
 
351
      if (writebuf)
352
        {
353
          ULONGEST addr;
354
 
355
          regcache_cooked_read_unsigned (regcache, MT_R11_REGNUM, &addr);
356
          write_memory (addr, writebuf, TYPE_LENGTH (type));
357
        }
358
 
359
      return RETURN_VALUE_ABI_RETURNS_ADDRESS;
360
    }
361
  else
362
    {
363
      if (readbuf)
364
        {
365
          ULONGEST temp;
366
 
367
          /* Return values of <= 4 bytes are returned in R11.  */
368
          regcache_cooked_read_unsigned (regcache, MT_R11_REGNUM, &temp);
369
          store_unsigned_integer (readbuf, TYPE_LENGTH (type), temp);
370
        }
371
 
372
      if (writebuf)
373
        {
374
          if (TYPE_LENGTH (type) < 4)
375
            {
376
              gdb_byte buf[4];
377
              /* Add leading zeros to the value.  */
378
              memset (buf, 0, sizeof (buf));
379
              memcpy (buf + sizeof (buf) - TYPE_LENGTH (type),
380
                      writebuf, TYPE_LENGTH (type));
381
              regcache_cooked_write (regcache, MT_R11_REGNUM, buf);
382
            }
383
          else                  /* (TYPE_LENGTH (type) == 4 */
384
            regcache_cooked_write (regcache, MT_R11_REGNUM, writebuf);
385
        }
386
 
387
      return RETURN_VALUE_REGISTER_CONVENTION;
388
    }
389
}
390
 
391
/* If the input address, PC, is in a function prologue, return the
392
   address of the end of the prologue, otherwise return the input
393
   address.
394
 
395
   Note:  PC is likely to be the function start, since this function
396
   is mainly used for advancing a breakpoint to the first line, or
397
   stepping to the first line when we have stepped into a function
398
   call.  */
399
 
400
static CORE_ADDR
401
mt_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
402
{
403
  CORE_ADDR func_addr = 0, func_end = 0;
404
  char *func_name;
405
  unsigned long instr;
406
 
407
  if (find_pc_partial_function (pc, &func_name, &func_addr, &func_end))
408
    {
409
      struct symtab_and_line sal;
410
      struct symbol *sym;
411
 
412
      /* Found a function.  */
413
      sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL, NULL);
414
      if (sym && SYMBOL_LANGUAGE (sym) != language_asm)
415
        {
416
          /* Don't use this trick for assembly source files.  */
417
          sal = find_pc_line (func_addr, 0);
418
 
419
          if (sal.end && sal.end < func_end)
420
            {
421
              /* Found a line number, use it as end of prologue.  */
422
              return sal.end;
423
            }
424
        }
425
    }
426
 
427
  /* No function symbol, or no line symbol.  Use prologue scanning method.  */
428
  for (;; pc += 4)
429
    {
430
      instr = read_memory_unsigned_integer (pc, 4);
431
      if (instr == 0x12000000)  /* nop */
432
        continue;
433
      if (instr == 0x12ddc000)  /* copy sp into fp */
434
        continue;
435
      instr >>= 16;
436
      if (instr == 0x05dd)      /* subi sp, sp, imm */
437
        continue;
438
      if (instr >= 0x43c0 && instr <= 0x43df)   /* push */
439
        continue;
440
      /* Not an obvious prologue instruction.  */
441
      break;
442
    }
443
 
444
  return pc;
445
}
446
 
447
/* The breakpoint instruction must be the same size as the smallest
448
   instruction in the instruction set.
449
 
450
   The BP for ms1 is defined as 0x68000000 (BREAK).
451
   The BP for ms2 is defined as 0x69000000 (illegal)  */
452
 
453
static const gdb_byte *
454
mt_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *bp_addr,
455
                       int *bp_size)
456
{
457
  static gdb_byte ms1_breakpoint[] = { 0x68, 0, 0, 0 };
458
  static gdb_byte ms2_breakpoint[] = { 0x69, 0, 0, 0 };
459
 
460
  *bp_size = 4;
461
  if (gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_ms2)
462
    return ms2_breakpoint;
463
 
464
  return ms1_breakpoint;
465
}
466
 
467
/* Select the correct coprocessor register bank.  Return the pseudo
468
   regnum we really want to read.  */
469
 
470
static int
471
mt_select_coprocessor (struct gdbarch *gdbarch,
472
                        struct regcache *regcache, int regno)
473
{
474
  unsigned index, base;
475
  gdb_byte copro[4];
476
 
477
  /* Get the copro pseudo regnum. */
478
  regcache_raw_read (regcache, MT_COPRO_REGNUM, copro);
479
  base = (extract_signed_integer (&copro[0], 2) * MT_COPRO_PSEUDOREG_DIM_2
480
          + extract_signed_integer (&copro[2], 2));
481
 
482
  regno -= MT_COPRO_PSEUDOREG_ARRAY;
483
  index = regno % MT_COPRO_PSEUDOREG_REGS;
484
  regno /= MT_COPRO_PSEUDOREG_REGS;
485
  if (base != regno)
486
    {
487
      /* Select the correct coprocessor register bank.  Invalidate the
488
         coprocessor register cache.  */
489
      unsigned ix;
490
 
491
      store_signed_integer (&copro[0], 2, regno / MT_COPRO_PSEUDOREG_DIM_2);
492
      store_signed_integer (&copro[2], 2, regno % MT_COPRO_PSEUDOREG_DIM_2);
493
      regcache_raw_write (regcache, MT_COPRO_REGNUM, copro);
494
 
495
      /* We must flush the cache, as it is now invalid.  */
496
      for (ix = MT_NUM_CPU_REGS; ix != MT_NUM_REGS; ix++)
497
        regcache_invalidate (regcache, ix);
498
    }
499
 
500
  return index;
501
}
502
 
503
/* Fetch the pseudo registers:
504
 
505
   There are two regular pseudo-registers:
506
   1) The 'coprocessor' pseudo-register (which mirrors the
507
   "real" coprocessor register sent by the target), and
508
   2) The 'MAC' pseudo-register (which represents the union
509
   of the original 32 bit target MAC register and the new
510
   8-bit extended-MAC register).
511
 
512
   Additionally there is an array of coprocessor registers which track
513
   the coprocessor registers for each coprocessor.  */
514
 
515
static void
516
mt_pseudo_register_read (struct gdbarch *gdbarch,
517
                          struct regcache *regcache, int regno, gdb_byte *buf)
518
{
519
  switch (regno)
520
    {
521
    case MT_COPRO_REGNUM:
522
    case MT_COPRO_PSEUDOREG_REGNUM:
523
      regcache_raw_read (regcache, MT_COPRO_REGNUM, buf);
524
      break;
525
    case MT_MAC_REGNUM:
526
    case MT_MAC_PSEUDOREG_REGNUM:
527
      if (gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_mrisc2
528
          || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_ms2)
529
        {
530
          ULONGEST oldmac = 0, ext_mac = 0;
531
          ULONGEST newmac;
532
 
533
          regcache_cooked_read_unsigned (regcache, MT_MAC_REGNUM, &oldmac);
534
          regcache_cooked_read_unsigned (regcache, MT_EXMAC_REGNUM, &ext_mac);
535
          newmac =
536
            (oldmac & 0xffffffff) | ((long long) (ext_mac & 0xff) << 32);
537
          store_signed_integer (buf, 8, newmac);
538
        }
539
      else
540
        regcache_raw_read (regcache, MT_MAC_REGNUM, buf);
541
      break;
542
    default:
543
      {
544
        unsigned index = mt_select_coprocessor (gdbarch, regcache, regno);
545
 
546
        if (index == MT_COPRO_PSEUDOREG_MAC_REGNUM)
547
          mt_pseudo_register_read (gdbarch, regcache,
548
                                   MT_MAC_PSEUDOREG_REGNUM, buf);
549
        else if (index < MT_NUM_REGS - MT_CPR0_REGNUM)
550
          regcache_raw_read (regcache, index + MT_CPR0_REGNUM, buf);
551
      }
552
      break;
553
    }
554
}
555
 
556
/* Write the pseudo registers:
557
 
558
   Mt pseudo-registers are stored directly to the target.  The
559
   'coprocessor' register is special, because when it is modified, all
560
   the other coprocessor regs must be flushed from the reg cache.  */
561
 
562
static void
563
mt_pseudo_register_write (struct gdbarch *gdbarch,
564
                           struct regcache *regcache,
565
                           int regno, const gdb_byte *buf)
566
{
567
  int i;
568
 
569
  switch (regno)
570
    {
571
    case MT_COPRO_REGNUM:
572
    case MT_COPRO_PSEUDOREG_REGNUM:
573
      regcache_raw_write (regcache, MT_COPRO_REGNUM, buf);
574
      for (i = MT_NUM_CPU_REGS; i < MT_NUM_REGS; i++)
575
        regcache_invalidate (regcache, i);
576
      break;
577
    case MT_MAC_REGNUM:
578
    case MT_MAC_PSEUDOREG_REGNUM:
579
      if (gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_mrisc2
580
          || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_ms2)
581
        {
582
          /* The 8-byte MAC pseudo-register must be broken down into two
583
             32-byte registers.  */
584
          unsigned int oldmac, ext_mac;
585
          ULONGEST newmac;
586
 
587
          newmac = extract_unsigned_integer (buf, 8);
588
          oldmac = newmac & 0xffffffff;
589
          ext_mac = (newmac >> 32) & 0xff;
590
          regcache_cooked_write_unsigned (regcache, MT_MAC_REGNUM, oldmac);
591
          regcache_cooked_write_unsigned (regcache, MT_EXMAC_REGNUM, ext_mac);
592
        }
593
      else
594
        regcache_raw_write (regcache, MT_MAC_REGNUM, buf);
595
      break;
596
    default:
597
      {
598
        unsigned index = mt_select_coprocessor (gdbarch, regcache, regno);
599
 
600
        if (index == MT_COPRO_PSEUDOREG_MAC_REGNUM)
601
          mt_pseudo_register_write (gdbarch, regcache,
602
                                    MT_MAC_PSEUDOREG_REGNUM, buf);
603
        else if (index < MT_NUM_REGS - MT_CPR0_REGNUM)
604
          regcache_raw_write (regcache, index + MT_CPR0_REGNUM, buf);
605
      }
606
      break;
607
    }
608
}
609
 
610
static CORE_ADDR
611
mt_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
612
{
613
  /* Register size is 4 bytes.  */
614
  return align_down (sp, 4);
615
}
616
 
617
/* Implements the "info registers" command.   When ``all'' is non-zero,
618
   the coprocessor registers will be printed in addition to the rest
619
   of the registers.  */
620
 
621
static void
622
mt_registers_info (struct gdbarch *gdbarch,
623
                   struct ui_file *file,
624
                   struct frame_info *frame, int regnum, int all)
625
{
626
  if (regnum == -1)
627
    {
628
      int lim;
629
 
630
      lim = all ? MT_NUM_REGS : MT_NUM_CPU_REGS;
631
 
632
      for (regnum = 0; regnum < lim; regnum++)
633
        {
634
          /* Don't display the Qchannel register since it will be displayed
635
             along with Ichannel.  (See below.)  */
636
          if (regnum == MT_QCHANNEL_REGNUM)
637
            continue;
638
 
639
          mt_registers_info (gdbarch, file, frame, regnum, all);
640
 
641
          /* Display the Qchannel register immediately after Ichannel.  */
642
          if (regnum == MT_ICHANNEL_REGNUM)
643
            mt_registers_info (gdbarch, file, frame, MT_QCHANNEL_REGNUM, all);
644
        }
645
    }
646
  else
647
    {
648
      if (regnum == MT_EXMAC_REGNUM)
649
        return;
650
      else if (regnum == MT_CONTEXT_REGNUM)
651
        {
652
          /* Special output handling for 38-bit context register.  */
653
          unsigned char *buff;
654
          unsigned int *bytes, i, regsize;
655
 
656
          regsize = register_size (gdbarch, regnum);
657
 
658
          buff = alloca (regsize);
659
          bytes = alloca (regsize * sizeof (*bytes));
660
 
661
          frame_register_read (frame, regnum, buff);
662
 
663
          fputs_filtered (gdbarch_register_name
664
                          (gdbarch, regnum), file);
665
          print_spaces_filtered (15 - strlen (gdbarch_register_name
666
                                                (gdbarch, regnum)),
667
                                 file);
668
          fputs_filtered ("0x", file);
669
 
670
          for (i = 0; i < regsize; i++)
671
            fprintf_filtered (file, "%02x", (unsigned int)
672
                              extract_unsigned_integer (buff + i, 1));
673
          fputs_filtered ("\t", file);
674
          print_longest (file, 'd', 0,
675
                         extract_unsigned_integer (buff, regsize));
676
          fputs_filtered ("\n", file);
677
        }
678
      else if (regnum == MT_COPRO_REGNUM
679
               || regnum == MT_COPRO_PSEUDOREG_REGNUM)
680
        {
681
          /* Special output handling for the 'coprocessor' register.  */
682
          gdb_byte *buf;
683
 
684
          buf = alloca (register_size (gdbarch, MT_COPRO_REGNUM));
685
          frame_register_read (frame, MT_COPRO_REGNUM, buf);
686
          /* And print.  */
687
          regnum = MT_COPRO_PSEUDOREG_REGNUM;
688
          fputs_filtered (gdbarch_register_name (gdbarch, regnum),
689
                          file);
690
          print_spaces_filtered (15 - strlen (gdbarch_register_name
691
                                                (gdbarch, regnum)),
692
                                 file);
693
          val_print (register_type (gdbarch, regnum), buf,
694
                     0, 0, file, 0, 1, 0, Val_no_prettyprint);
695
          fputs_filtered ("\n", file);
696
        }
697
      else if (regnum == MT_MAC_REGNUM || regnum == MT_MAC_PSEUDOREG_REGNUM)
698
        {
699
          ULONGEST oldmac, ext_mac, newmac;
700
          gdb_byte buf[3 * sizeof (LONGEST)];
701
 
702
          /* Get the two "real" mac registers.  */
703
          frame_register_read (frame, MT_MAC_REGNUM, buf);
704
          oldmac = extract_unsigned_integer
705
            (buf, register_size (gdbarch, MT_MAC_REGNUM));
706
          if (gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_mrisc2
707
              || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_ms2)
708
            {
709
              frame_register_read (frame, MT_EXMAC_REGNUM, buf);
710
              ext_mac = extract_unsigned_integer
711
                (buf, register_size (gdbarch, MT_EXMAC_REGNUM));
712
            }
713
          else
714
            ext_mac = 0;
715
 
716
          /* Add them together.  */
717
          newmac = (oldmac & 0xffffffff) + ((ext_mac & 0xff) << 32);
718
 
719
          /* And print.  */
720
          regnum = MT_MAC_PSEUDOREG_REGNUM;
721
          fputs_filtered (gdbarch_register_name (gdbarch, regnum),
722
                          file);
723
          print_spaces_filtered (15 - strlen (gdbarch_register_name
724
                                              (gdbarch, regnum)),
725
                                 file);
726
          fputs_filtered ("0x", file);
727
          print_longest (file, 'x', 0, newmac);
728
          fputs_filtered ("\t", file);
729
          print_longest (file, 'u', 0, newmac);
730
          fputs_filtered ("\n", file);
731
        }
732
      else
733
        default_print_registers_info (gdbarch, file, frame, regnum, all);
734
    }
735
}
736
 
737
/* Set up the callee's arguments for an inferior function call.  The
738
   arguments are pushed on the stack or are placed in registers as
739
   appropriate.  It also sets up the return address (which points to
740
   the call dummy breakpoint).
741
 
742
   Returns the updated (and aligned) stack pointer.  */
743
 
744
static CORE_ADDR
745
mt_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
746
                     struct regcache *regcache, CORE_ADDR bp_addr,
747
                     int nargs, struct value **args, CORE_ADDR sp,
748
                     int struct_return, CORE_ADDR struct_addr)
749
{
750
#define wordsize 4
751
  gdb_byte buf[MT_MAX_STRUCT_SIZE];
752
  int argreg = MT_1ST_ARGREG;
753
  int split_param_len = 0;
754
  int stack_dest = sp;
755
  int slacklen;
756
  int typelen;
757
  int i, j;
758
 
759
  /* First handle however many args we can fit into MT_1ST_ARGREG thru
760
     MT_LAST_ARGREG.  */
761
  for (i = 0; i < nargs && argreg <= MT_LAST_ARGREG; i++)
762
    {
763
      const gdb_byte *val;
764
      typelen = TYPE_LENGTH (value_type (args[i]));
765
      switch (typelen)
766
        {
767
        case 1:
768
        case 2:
769
        case 3:
770
        case 4:
771
          regcache_cooked_write_unsigned (regcache, argreg++,
772
                                          extract_unsigned_integer
773
                                          (value_contents (args[i]),
774
                                           wordsize));
775
          break;
776
        case 8:
777
        case 12:
778
        case 16:
779
          val = value_contents (args[i]);
780
          while (typelen > 0)
781
            {
782
              if (argreg <= MT_LAST_ARGREG)
783
                {
784
                  /* This word of the argument is passed in a register.  */
785
                  regcache_cooked_write_unsigned (regcache, argreg++,
786
                                                  extract_unsigned_integer
787
                                                  (val, wordsize));
788
                  typelen -= wordsize;
789
                  val += wordsize;
790
                }
791
              else
792
                {
793
                  /* Remainder of this arg must be passed on the stack
794
                     (deferred to do later).  */
795
                  split_param_len = typelen;
796
                  memcpy (buf, val, typelen);
797
                  break;        /* No more args can be handled in regs.  */
798
                }
799
            }
800
          break;
801
        default:
802
          /* By reverse engineering of gcc output, args bigger than
803
             16 bytes go on the stack, and their address is passed
804
             in the argreg.  */
805
          stack_dest -= typelen;
806
          write_memory (stack_dest, value_contents (args[i]), typelen);
807
          regcache_cooked_write_unsigned (regcache, argreg++, stack_dest);
808
          break;
809
        }
810
    }
811
 
812
  /* Next, the rest of the arguments go onto the stack, in reverse order.  */
813
  for (j = nargs - 1; j >= i; j--)
814
    {
815
      gdb_byte *val;
816
 
817
      /* Right-justify the value in an aligned-length buffer.  */
818
      typelen = TYPE_LENGTH (value_type (args[j]));
819
      slacklen = (wordsize - (typelen % wordsize)) % wordsize;
820
      val = alloca (typelen + slacklen);
821
      memcpy (val, value_contents (args[j]), typelen);
822
      memset (val + typelen, 0, slacklen);
823
      /* Now write this data to the stack.  */
824
      stack_dest -= typelen + slacklen;
825
      write_memory (stack_dest, val, typelen + slacklen);
826
    }
827
 
828
  /* Finally, if a param needs to be split between registers and stack,
829
     write the second half to the stack now.  */
830
  if (split_param_len != 0)
831
    {
832
      stack_dest -= split_param_len;
833
      write_memory (stack_dest, buf, split_param_len);
834
    }
835
 
836
  /* Set up return address (provided to us as bp_addr).  */
837
  regcache_cooked_write_unsigned (regcache, MT_RA_REGNUM, bp_addr);
838
 
839
  /* Store struct return address, if given.  */
840
  if (struct_return && struct_addr != 0)
841
    regcache_cooked_write_unsigned (regcache, MT_R11_REGNUM, struct_addr);
842
 
843
  /* Set aside 16 bytes for the callee to save regs 1-4.  */
844
  stack_dest -= 16;
845
 
846
  /* Update the stack pointer.  */
847
  regcache_cooked_write_unsigned (regcache, MT_SP_REGNUM, stack_dest);
848
 
849
  /* And that should do it.  Return the new stack pointer.  */
850
  return stack_dest;
851
}
852
 
853
 
854
/* The 'unwind_cache' data structure.  */
855
 
856
struct mt_unwind_cache
857
{
858
  /* The previous frame's inner most stack address.
859
     Used as this frame ID's stack_addr.  */
860
  CORE_ADDR prev_sp;
861
  CORE_ADDR frame_base;
862
  int framesize;
863
  int frameless_p;
864
 
865
  /* Table indicating the location of each and every register.  */
866
  struct trad_frame_saved_reg *saved_regs;
867
};
868
 
869
/* Initialize an unwind_cache.  Build up the saved_regs table etc. for
870
   the frame.  */
871
 
872
static struct mt_unwind_cache *
873
mt_frame_unwind_cache (struct frame_info *next_frame,
874
                        void **this_prologue_cache)
875
{
876
  struct gdbarch *gdbarch;
877
  struct mt_unwind_cache *info;
878
  CORE_ADDR next_addr, start_addr, end_addr, prologue_end_addr;
879
  unsigned long instr, upper_half, delayed_store = 0;
880
  int regnum, offset;
881
  ULONGEST sp, fp;
882
 
883
  if ((*this_prologue_cache))
884
    return (*this_prologue_cache);
885
 
886
  gdbarch = get_frame_arch (next_frame);
887
  info = FRAME_OBSTACK_ZALLOC (struct mt_unwind_cache);
888
  (*this_prologue_cache) = info;
889
 
890
  info->prev_sp = 0;
891
  info->framesize = 0;
892
  info->frame_base = 0;
893
  info->frameless_p = 1;
894
  info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
895
 
896
  /* Grab the frame-relative values of SP and FP, needed below.
897
     The frame_saved_register function will find them on the
898
     stack or in the registers as appropriate.  */
899
  sp = frame_unwind_register_unsigned (next_frame, MT_SP_REGNUM);
900
  fp = frame_unwind_register_unsigned (next_frame, MT_FP_REGNUM);
901
 
902
  start_addr = frame_func_unwind (next_frame, NORMAL_FRAME);
903
 
904
  /* Return early if GDB couldn't find the function.  */
905
  if (start_addr == 0)
906
    return info;
907
 
908
  end_addr = frame_pc_unwind (next_frame);
909
  prologue_end_addr = skip_prologue_using_sal (start_addr);
910
  if (end_addr == 0)
911
  for (next_addr = start_addr; next_addr < end_addr; next_addr += 4)
912
    {
913
      instr = get_frame_memory_unsigned (next_frame, next_addr, 4);
914
      if (delayed_store)        /* previous instr was a push */
915
        {
916
          upper_half = delayed_store >> 16;
917
          regnum = upper_half & 0xf;
918
          offset = delayed_store & 0xffff;
919
          switch (upper_half & 0xfff0)
920
            {
921
            case 0x43c0:        /* push using frame pointer */
922
              info->saved_regs[regnum].addr = offset;
923
              break;
924
            case 0x43d0:        /* push using stack pointer */
925
              info->saved_regs[regnum].addr = offset;
926
              break;
927
            default:            /* lint */
928
              break;
929
            }
930
          delayed_store = 0;
931
        }
932
 
933
      switch (instr)
934
        {
935
        case 0x12000000:        /* NO-OP */
936
          continue;
937
        case 0x12ddc000:        /* copy sp into fp */
938
          info->frameless_p = 0; /* Record that the frame pointer is in use.  */
939
          continue;
940
        default:
941
          upper_half = instr >> 16;
942
          if (upper_half == 0x05dd ||   /* subi  sp, sp, imm */
943
              upper_half == 0x07dd)     /* subui sp, sp, imm */
944
            {
945
              /* Record the frame size.  */
946
              info->framesize = instr & 0xffff;
947
              continue;
948
            }
949
          if ((upper_half & 0xfff0) == 0x43c0 ||        /* frame push */
950
              (upper_half & 0xfff0) == 0x43d0)  /* stack push */
951
            {
952
              /* Save this instruction, but don't record the
953
                 pushed register as 'saved' until we see the
954
                 next instruction.  That's because of deferred stores
955
                 on this target -- GDB won't be able to read the register
956
                 from the stack until one instruction later.  */
957
              delayed_store = instr;
958
              continue;
959
            }
960
          /* Not a prologue instruction.  Is this the end of the prologue?
961
             This is the most difficult decision; when to stop scanning.
962
 
963
             If we have no line symbol, then the best thing we can do
964
             is to stop scanning when we encounter an instruction that
965
             is not likely to be a part of the prologue.
966
 
967
             But if we do have a line symbol, then we should
968
             keep scanning until we reach it (or we reach end_addr).  */
969
 
970
          if (prologue_end_addr && (prologue_end_addr > (next_addr + 4)))
971
            continue;           /* Keep scanning, recording saved_regs etc.  */
972
          else
973
            break;              /* Quit scanning: breakpoint can be set here.  */
974
        }
975
    }
976
 
977
  /* Special handling for the "saved" address of the SP:
978
     The SP is of course never saved on the stack at all, so
979
     by convention what we put here is simply the previous
980
     _value_ of the SP (as opposed to an address where the
981
     previous value would have been pushed).  This will also
982
     give us the frame base address.  */
983
 
984
  if (info->frameless_p)
985
    {
986
      info->frame_base = sp + info->framesize;
987
      info->prev_sp = sp + info->framesize;
988
    }
989
  else
990
    {
991
      info->frame_base = fp + info->framesize;
992
      info->prev_sp = fp + info->framesize;
993
    }
994
  /* Save prev_sp in saved_regs as a value, not as an address.  */
995
  trad_frame_set_value (info->saved_regs, MT_SP_REGNUM, info->prev_sp);
996
 
997
  /* Now convert frame offsets to actual addresses (not offsets).  */
998
  for (regnum = 0; regnum < MT_NUM_REGS; regnum++)
999
    if (trad_frame_addr_p (info->saved_regs, regnum))
1000
      info->saved_regs[regnum].addr += info->frame_base - info->framesize;
1001
 
1002
  /* The call instruction moves the caller's PC in the callee's RA reg.
1003
     Since this is an unwind, do the reverse.  Copy the location of RA
1004
     into PC (the address / regnum) so that a request for PC will be
1005
     converted into a request for the RA.  */
1006
  info->saved_regs[MT_PC_REGNUM] = info->saved_regs[MT_RA_REGNUM];
1007
 
1008
  return info;
1009
}
1010
 
1011
static CORE_ADDR
1012
mt_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
1013
{
1014
  ULONGEST pc;
1015
 
1016
  pc = frame_unwind_register_unsigned (next_frame, MT_PC_REGNUM);
1017
  return pc;
1018
}
1019
 
1020
static CORE_ADDR
1021
mt_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
1022
{
1023
  ULONGEST sp;
1024
 
1025
  sp = frame_unwind_register_unsigned (next_frame, MT_SP_REGNUM);
1026
  return sp;
1027
}
1028
 
1029
/* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
1030
   dummy frame.  The frame ID's base needs to match the TOS value
1031
   saved by save_dummy_frame_tos(), and the PC match the dummy frame's
1032
   breakpoint.  */
1033
 
1034
static struct frame_id
1035
mt_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
1036
{
1037
  return frame_id_build (mt_unwind_sp (gdbarch, next_frame),
1038
                         frame_pc_unwind (next_frame));
1039
}
1040
 
1041
/* Given a GDB frame, determine the address of the calling function's
1042
   frame.  This will be used to create a new GDB frame struct.  */
1043
 
1044
static void
1045
mt_frame_this_id (struct frame_info *next_frame,
1046
                   void **this_prologue_cache, struct frame_id *this_id)
1047
{
1048
  struct mt_unwind_cache *info =
1049
    mt_frame_unwind_cache (next_frame, this_prologue_cache);
1050
 
1051
  if (!(info == NULL || info->prev_sp == 0))
1052
    (*this_id) = frame_id_build (info->prev_sp,
1053
                                 frame_func_unwind (next_frame, NORMAL_FRAME));
1054
 
1055
  return;
1056
}
1057
 
1058
static void
1059
mt_frame_prev_register (struct frame_info *next_frame,
1060
                         void **this_prologue_cache,
1061
                         int regnum, int *optimizedp,
1062
                         enum lval_type *lvalp, CORE_ADDR *addrp,
1063
                         int *realnump, gdb_byte *bufferp)
1064
{
1065
  struct mt_unwind_cache *info =
1066
    mt_frame_unwind_cache (next_frame, this_prologue_cache);
1067
 
1068
  trad_frame_get_prev_register (next_frame, info->saved_regs, regnum,
1069
                                optimizedp, lvalp, addrp, realnump, bufferp);
1070
}
1071
 
1072
static CORE_ADDR
1073
mt_frame_base_address (struct frame_info *next_frame,
1074
                        void **this_prologue_cache)
1075
{
1076
  struct mt_unwind_cache *info =
1077
    mt_frame_unwind_cache (next_frame, this_prologue_cache);
1078
 
1079
  return info->frame_base;
1080
}
1081
 
1082
/* This is a shared interface:  the 'frame_unwind' object is what's
1083
   returned by the 'sniffer' function, and in turn specifies how to
1084
   get a frame's ID and prev_regs.
1085
 
1086
   This exports the 'prev_register' and 'this_id' methods.  */
1087
 
1088
static const struct frame_unwind mt_frame_unwind = {
1089
  NORMAL_FRAME,
1090
  mt_frame_this_id,
1091
  mt_frame_prev_register
1092
};
1093
 
1094
/* The sniffer is a registered function that identifies our family of
1095
   frame unwind functions (this_id and prev_register).  */
1096
 
1097
static const struct frame_unwind *
1098
mt_frame_sniffer (struct frame_info *next_frame)
1099
{
1100
  return &mt_frame_unwind;
1101
}
1102
 
1103
/* Another shared interface:  the 'frame_base' object specifies how to
1104
   unwind a frame and secure the base addresses for frame objects
1105
   (locals, args).  */
1106
 
1107
static struct frame_base mt_frame_base = {
1108
  &mt_frame_unwind,
1109
  mt_frame_base_address,
1110
  mt_frame_base_address,
1111
  mt_frame_base_address
1112
};
1113
 
1114
static struct gdbarch *
1115
mt_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1116
{
1117
  struct gdbarch *gdbarch;
1118
 
1119
  /* Find a candidate among the list of pre-declared architectures.  */
1120
  arches = gdbarch_list_lookup_by_info (arches, &info);
1121
  if (arches != NULL)
1122
    return arches->gdbarch;
1123
 
1124
  /* None found, create a new architecture from the information
1125
     provided.  */
1126
  gdbarch = gdbarch_alloc (&info, NULL);
1127
 
1128
  set_gdbarch_float_format (gdbarch, floatformats_ieee_single);
1129
  set_gdbarch_double_format (gdbarch, floatformats_ieee_double);
1130
  set_gdbarch_long_double_format (gdbarch, floatformats_ieee_double);
1131
 
1132
  set_gdbarch_register_name (gdbarch, mt_register_name);
1133
  set_gdbarch_num_regs (gdbarch, MT_NUM_REGS);
1134
  set_gdbarch_num_pseudo_regs (gdbarch, MT_NUM_PSEUDO_REGS);
1135
  set_gdbarch_pc_regnum (gdbarch, MT_PC_REGNUM);
1136
  set_gdbarch_sp_regnum (gdbarch, MT_SP_REGNUM);
1137
  set_gdbarch_pseudo_register_read (gdbarch, mt_pseudo_register_read);
1138
  set_gdbarch_pseudo_register_write (gdbarch, mt_pseudo_register_write);
1139
  set_gdbarch_skip_prologue (gdbarch, mt_skip_prologue);
1140
  set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1141
  set_gdbarch_breakpoint_from_pc (gdbarch, mt_breakpoint_from_pc);
1142
  set_gdbarch_decr_pc_after_break (gdbarch, 0);
1143
  set_gdbarch_frame_args_skip (gdbarch, 0);
1144
  set_gdbarch_print_insn (gdbarch, print_insn_mt);
1145
  set_gdbarch_register_type (gdbarch, mt_register_type);
1146
  set_gdbarch_register_reggroup_p (gdbarch, mt_register_reggroup_p);
1147
 
1148
  set_gdbarch_return_value (gdbarch, mt_return_value);
1149
  set_gdbarch_sp_regnum (gdbarch, MT_SP_REGNUM);
1150
 
1151
  set_gdbarch_frame_align (gdbarch, mt_frame_align);
1152
 
1153
  set_gdbarch_print_registers_info (gdbarch, mt_registers_info);
1154
 
1155
  set_gdbarch_push_dummy_call (gdbarch, mt_push_dummy_call);
1156
 
1157
  /* Target builtin data types.  */
1158
  set_gdbarch_short_bit (gdbarch, 16);
1159
  set_gdbarch_int_bit (gdbarch, 32);
1160
  set_gdbarch_long_bit (gdbarch, 32);
1161
  set_gdbarch_long_long_bit (gdbarch, 64);
1162
  set_gdbarch_float_bit (gdbarch, 32);
1163
  set_gdbarch_double_bit (gdbarch, 64);
1164
  set_gdbarch_long_double_bit (gdbarch, 64);
1165
  set_gdbarch_ptr_bit (gdbarch, 32);
1166
 
1167
  /* Register the DWARF 2 sniffer first, and then the traditional prologue
1168
     based sniffer.  */
1169
  frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
1170
  frame_unwind_append_sniffer (gdbarch, mt_frame_sniffer);
1171
  frame_base_set_default (gdbarch, &mt_frame_base);
1172
 
1173
  /* Register the 'unwind_pc' method.  */
1174
  set_gdbarch_unwind_pc (gdbarch, mt_unwind_pc);
1175
  set_gdbarch_unwind_sp (gdbarch, mt_unwind_sp);
1176
 
1177
  /* Methods for saving / extracting a dummy frame's ID.
1178
     The ID's stack address must match the SP value returned by
1179
     PUSH_DUMMY_CALL, and saved by generic_save_dummy_frame_tos.  */
1180
  set_gdbarch_unwind_dummy_id (gdbarch, mt_unwind_dummy_id);
1181
 
1182
  return gdbarch;
1183
}
1184
 
1185
void
1186
_initialize_mt_tdep (void)
1187
{
1188
  register_gdbarch_init (bfd_arch_mt, mt_gdbarch_init);
1189
}

powered by: WebSVN 2.1.0

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