OpenCores
URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [gdb/] [m68k-tdep.c] - Blame information for rev 227

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* Target-dependent code for the Motorola 68000 series.
2
 
3
   Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1999, 2000, 2001,
4
   2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
5
   Free Software Foundation, Inc.
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 3 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, see <http://www.gnu.org/licenses/>.  */
21
 
22
#include "defs.h"
23
#include "dwarf2-frame.h"
24
#include "frame.h"
25
#include "frame-base.h"
26
#include "frame-unwind.h"
27
#include "gdbtypes.h"
28
#include "symtab.h"
29
#include "gdbcore.h"
30
#include "value.h"
31
#include "gdb_string.h"
32
#include "gdb_assert.h"
33
#include "inferior.h"
34
#include "regcache.h"
35
#include "arch-utils.h"
36
#include "osabi.h"
37
#include "dis-asm.h"
38
#include "target-descriptions.h"
39
 
40
#include "m68k-tdep.h"
41
 
42
 
43
#define P_LINKL_FP      0x480e
44
#define P_LINKW_FP      0x4e56
45
#define P_PEA_FP        0x4856
46
#define P_MOVEAL_SP_FP  0x2c4f
47
#define P_ADDAW_SP      0xdefc
48
#define P_ADDAL_SP      0xdffc
49
#define P_SUBQW_SP      0x514f
50
#define P_SUBQL_SP      0x518f
51
#define P_LEA_SP_SP     0x4fef
52
#define P_LEA_PC_A5     0x4bfb0170
53
#define P_FMOVEMX_SP    0xf227
54
#define P_MOVEL_SP      0x2f00
55
#define P_MOVEML_SP     0x48e7
56
 
57
/* Offset from SP to first arg on stack at first instruction of a function */
58
#define SP_ARG0 (1 * 4)
59
 
60
#if !defined (BPT_VECTOR)
61
#define BPT_VECTOR 0xf
62
#endif
63
 
64
static const gdb_byte *
65
m68k_local_breakpoint_from_pc (struct gdbarch *gdbarch,
66
                               CORE_ADDR *pcptr, int *lenptr)
67
{
68
  static gdb_byte break_insn[] = {0x4e, (0x40 | BPT_VECTOR)};
69
  *lenptr = sizeof (break_insn);
70
  return break_insn;
71
}
72
 
73
 
74
/* Construct types for ISA-specific registers.  */
75
static struct type *
76
m68k_ps_type (struct gdbarch *gdbarch)
77
{
78
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
79
 
80
  if (!tdep->m68k_ps_type)
81
    {
82
      struct type *type;
83
 
84
      type = arch_flags_type (gdbarch, "builtin_type_m68k_ps", 4);
85
      append_flags_type_flag (type, 0, "C");
86
      append_flags_type_flag (type, 1, "V");
87
      append_flags_type_flag (type, 2, "Z");
88
      append_flags_type_flag (type, 3, "N");
89
      append_flags_type_flag (type, 4, "X");
90
      append_flags_type_flag (type, 8, "I0");
91
      append_flags_type_flag (type, 9, "I1");
92
      append_flags_type_flag (type, 10, "I2");
93
      append_flags_type_flag (type, 12, "M");
94
      append_flags_type_flag (type, 13, "S");
95
      append_flags_type_flag (type, 14, "T0");
96
      append_flags_type_flag (type, 15, "T1");
97
 
98
      tdep->m68k_ps_type = type;
99
    }
100
 
101
  return tdep->m68k_ps_type;
102
}
103
 
104
static struct type *
105
m68881_ext_type (struct gdbarch *gdbarch)
106
{
107
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
108
 
109
  if (!tdep->m68881_ext_type)
110
    tdep->m68881_ext_type
111
      = arch_float_type (gdbarch, -1, "builtin_type_m68881_ext",
112
                         floatformats_m68881_ext);
113
 
114
  return tdep->m68881_ext_type;
115
}
116
 
117
/* Return the GDB type object for the "standard" data type of data in
118
   register N.  This should be int for D0-D7, SR, FPCONTROL and
119
   FPSTATUS, long double for FP0-FP7, and void pointer for all others
120
   (A0-A7, PC, FPIADDR).  Note, for registers which contain
121
   addresses return pointer to void, not pointer to char, because we
122
   don't want to attempt to print the string after printing the
123
   address.  */
124
 
125
static struct type *
126
m68k_register_type (struct gdbarch *gdbarch, int regnum)
127
{
128
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
129
 
130
  if (tdep->fpregs_present)
131
    {
132
      if (regnum >= gdbarch_fp0_regnum (gdbarch)
133
          && regnum <= gdbarch_fp0_regnum (gdbarch) + 7)
134
        {
135
          if (tdep->flavour == m68k_coldfire_flavour)
136
            return builtin_type (gdbarch)->builtin_double;
137
          else
138
            return m68881_ext_type (gdbarch);
139
        }
140
 
141
      if (regnum == M68K_FPI_REGNUM)
142
        return builtin_type (gdbarch)->builtin_func_ptr;
143
 
144
      if (regnum == M68K_FPC_REGNUM || regnum == M68K_FPS_REGNUM)
145
        return builtin_type (gdbarch)->builtin_int32;
146
    }
147
  else
148
    {
149
      if (regnum >= M68K_FP0_REGNUM && regnum <= M68K_FPI_REGNUM)
150
        return builtin_type (gdbarch)->builtin_int0;
151
    }
152
 
153
  if (regnum == gdbarch_pc_regnum (gdbarch))
154
    return builtin_type (gdbarch)->builtin_func_ptr;
155
 
156
  if (regnum >= M68K_A0_REGNUM && regnum <= M68K_A0_REGNUM + 7)
157
    return builtin_type (gdbarch)->builtin_data_ptr;
158
 
159
  if (regnum == M68K_PS_REGNUM)
160
    return m68k_ps_type (gdbarch);
161
 
162
  return builtin_type (gdbarch)->builtin_int32;
163
}
164
 
165
static const char *m68k_register_names[] = {
166
    "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
167
    "a0", "a1", "a2", "a3", "a4", "a5", "fp", "sp",
168
    "ps", "pc",
169
    "fp0", "fp1", "fp2", "fp3", "fp4", "fp5", "fp6", "fp7",
170
    "fpcontrol", "fpstatus", "fpiaddr"
171
  };
172
 
173
/* Function: m68k_register_name
174
   Returns the name of the standard m68k register regnum. */
175
 
176
static const char *
177
m68k_register_name (struct gdbarch *gdbarch, int regnum)
178
{
179
  if (regnum < 0 || regnum >= ARRAY_SIZE (m68k_register_names))
180
    internal_error (__FILE__, __LINE__,
181
                    _("m68k_register_name: illegal register number %d"), regnum);
182
  else if (regnum >= M68K_FP0_REGNUM && regnum <= M68K_FPI_REGNUM
183
           && gdbarch_tdep (gdbarch)->fpregs_present == 0)
184
    return "";
185
  else
186
    return m68k_register_names[regnum];
187
}
188
 
189
/* Return nonzero if a value of type TYPE stored in register REGNUM
190
   needs any special handling.  */
191
 
192
static int
193
m68k_convert_register_p (struct gdbarch *gdbarch, int regnum, struct type *type)
194
{
195
  if (!gdbarch_tdep (gdbarch)->fpregs_present)
196
    return 0;
197
  return (regnum >= M68K_FP0_REGNUM && regnum <= M68K_FP0_REGNUM + 7
198
          && type != register_type (gdbarch, M68K_FP0_REGNUM));
199
}
200
 
201
/* Read a value of type TYPE from register REGNUM in frame FRAME, and
202
   return its contents in TO.  */
203
 
204
static void
205
m68k_register_to_value (struct frame_info *frame, int regnum,
206
                        struct type *type, gdb_byte *to)
207
{
208
  gdb_byte from[M68K_MAX_REGISTER_SIZE];
209
  struct type *fpreg_type = register_type (get_frame_arch (frame),
210
                                           M68K_FP0_REGNUM);
211
 
212
  /* We only support floating-point values.  */
213
  if (TYPE_CODE (type) != TYPE_CODE_FLT)
214
    {
215
      warning (_("Cannot convert floating-point register value "
216
               "to non-floating-point type."));
217
      return;
218
    }
219
 
220
  /* Convert to TYPE.  */
221
  get_frame_register (frame, regnum, from);
222
  convert_typed_floating (from, fpreg_type, to, type);
223
}
224
 
225
/* Write the contents FROM of a value of type TYPE into register
226
   REGNUM in frame FRAME.  */
227
 
228
static void
229
m68k_value_to_register (struct frame_info *frame, int regnum,
230
                        struct type *type, const gdb_byte *from)
231
{
232
  gdb_byte to[M68K_MAX_REGISTER_SIZE];
233
  struct type *fpreg_type = register_type (get_frame_arch (frame),
234
                                           M68K_FP0_REGNUM);
235
 
236
  /* We only support floating-point values.  */
237
  if (TYPE_CODE (type) != TYPE_CODE_FLT)
238
    {
239
      warning (_("Cannot convert non-floating-point type "
240
               "to floating-point register value."));
241
      return;
242
    }
243
 
244
  /* Convert from TYPE.  */
245
  convert_typed_floating (from, type, to, fpreg_type);
246
  put_frame_register (frame, regnum, to);
247
}
248
 
249
 
250
/* There is a fair number of calling conventions that are in somewhat
251
   wide use.  The 68000/08/10 don't support an FPU, not even as a
252
   coprocessor.  All function return values are stored in %d0/%d1.
253
   Structures are returned in a static buffer, a pointer to which is
254
   returned in %d0.  This means that functions returning a structure
255
   are not re-entrant.  To avoid this problem some systems use a
256
   convention where the caller passes a pointer to a buffer in %a1
257
   where the return values is to be stored.  This convention is the
258
   default, and is implemented in the function m68k_return_value.
259
 
260
   The 68020/030/040/060 do support an FPU, either as a coprocessor
261
   (68881/2) or built-in (68040/68060).  That's why System V release 4
262
   (SVR4) instroduces a new calling convention specified by the SVR4
263
   psABI.  Integer values are returned in %d0/%d1, pointer return
264
   values in %a0 and floating values in %fp0.  When calling functions
265
   returning a structure the caller should pass a pointer to a buffer
266
   for the return value in %a0.  This convention is implemented in the
267
   function m68k_svr4_return_value, and by appropriately setting the
268
   struct_value_regnum member of `struct gdbarch_tdep'.
269
 
270
   GNU/Linux returns values in the same way as SVR4 does, but uses %a1
271
   for passing the structure return value buffer.
272
 
273
   GCC can also generate code where small structures are returned in
274
   %d0/%d1 instead of in memory by using -freg-struct-return.  This is
275
   the default on NetBSD a.out, OpenBSD and GNU/Linux and several
276
   embedded systems.  This convention is implemented by setting the
277
   struct_return member of `struct gdbarch_tdep' to reg_struct_return.  */
278
 
279
/* Read a function return value of TYPE from REGCACHE, and copy that
280
   into VALBUF.  */
281
 
282
static void
283
m68k_extract_return_value (struct type *type, struct regcache *regcache,
284
                           gdb_byte *valbuf)
285
{
286
  int len = TYPE_LENGTH (type);
287
  gdb_byte buf[M68K_MAX_REGISTER_SIZE];
288
 
289
  if (len <= 4)
290
    {
291
      regcache_raw_read (regcache, M68K_D0_REGNUM, buf);
292
      memcpy (valbuf, buf + (4 - len), len);
293
    }
294
  else if (len <= 8)
295
    {
296
      regcache_raw_read (regcache, M68K_D0_REGNUM, buf);
297
      memcpy (valbuf, buf + (8 - len), len - 4);
298
      regcache_raw_read (regcache, M68K_D1_REGNUM, valbuf + (len - 4));
299
    }
300
  else
301
    internal_error (__FILE__, __LINE__,
302
                    _("Cannot extract return value of %d bytes long."), len);
303
}
304
 
305
static void
306
m68k_svr4_extract_return_value (struct type *type, struct regcache *regcache,
307
                                gdb_byte *valbuf)
308
{
309
  int len = TYPE_LENGTH (type);
310
  gdb_byte buf[M68K_MAX_REGISTER_SIZE];
311
  struct gdbarch *gdbarch = get_regcache_arch (regcache);
312
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
313
 
314
  if (tdep->float_return && TYPE_CODE (type) == TYPE_CODE_FLT)
315
    {
316
      struct type *fpreg_type = register_type (gdbarch, M68K_FP0_REGNUM);
317
      regcache_raw_read (regcache, M68K_FP0_REGNUM, buf);
318
      convert_typed_floating (buf, fpreg_type, valbuf, type);
319
    }
320
  else if (TYPE_CODE (type) == TYPE_CODE_PTR && len == 4)
321
    regcache_raw_read (regcache, M68K_A0_REGNUM, valbuf);
322
  else
323
    m68k_extract_return_value (type, regcache, valbuf);
324
}
325
 
326
/* Write a function return value of TYPE from VALBUF into REGCACHE.  */
327
 
328
static void
329
m68k_store_return_value (struct type *type, struct regcache *regcache,
330
                         const gdb_byte *valbuf)
331
{
332
  int len = TYPE_LENGTH (type);
333
 
334
  if (len <= 4)
335
    regcache_raw_write_part (regcache, M68K_D0_REGNUM, 4 - len, len, valbuf);
336
  else if (len <= 8)
337
    {
338
      regcache_raw_write_part (regcache, M68K_D0_REGNUM, 8 - len,
339
                               len - 4, valbuf);
340
      regcache_raw_write (regcache, M68K_D1_REGNUM, valbuf + (len - 4));
341
    }
342
  else
343
    internal_error (__FILE__, __LINE__,
344
                    _("Cannot store return value of %d bytes long."), len);
345
}
346
 
347
static void
348
m68k_svr4_store_return_value (struct type *type, struct regcache *regcache,
349
                              const gdb_byte *valbuf)
350
{
351
  int len = TYPE_LENGTH (type);
352
  struct gdbarch *gdbarch = get_regcache_arch (regcache);
353
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
354
 
355
  if (tdep->float_return && TYPE_CODE (type) == TYPE_CODE_FLT)
356
    {
357
      struct type *fpreg_type = register_type (gdbarch, M68K_FP0_REGNUM);
358
      gdb_byte buf[M68K_MAX_REGISTER_SIZE];
359
      convert_typed_floating (valbuf, type, buf, fpreg_type);
360
      regcache_raw_write (regcache, M68K_FP0_REGNUM, buf);
361
    }
362
  else if (TYPE_CODE (type) == TYPE_CODE_PTR && len == 4)
363
    {
364
      regcache_raw_write (regcache, M68K_A0_REGNUM, valbuf);
365
      regcache_raw_write (regcache, M68K_D0_REGNUM, valbuf);
366
    }
367
  else
368
    m68k_store_return_value (type, regcache, valbuf);
369
}
370
 
371
/* Return non-zero if TYPE, which is assumed to be a structure or
372
   union type, should be returned in registers for architecture
373
   GDBARCH.  */
374
 
375
static int
376
m68k_reg_struct_return_p (struct gdbarch *gdbarch, struct type *type)
377
{
378
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
379
  enum type_code code = TYPE_CODE (type);
380
  int len = TYPE_LENGTH (type);
381
 
382
  gdb_assert (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION);
383
 
384
  if (tdep->struct_return == pcc_struct_return)
385
    return 0;
386
 
387
  return (len == 1 || len == 2 || len == 4 || len == 8);
388
}
389
 
390
/* Determine, for architecture GDBARCH, how a return value of TYPE
391
   should be returned.  If it is supposed to be returned in registers,
392
   and READBUF is non-zero, read the appropriate value from REGCACHE,
393
   and copy it into READBUF.  If WRITEBUF is non-zero, write the value
394
   from WRITEBUF into REGCACHE.  */
395
 
396
static enum return_value_convention
397
m68k_return_value (struct gdbarch *gdbarch, struct type *func_type,
398
                   struct type *type, struct regcache *regcache,
399
                   gdb_byte *readbuf, const gdb_byte *writebuf)
400
{
401
  enum type_code code = TYPE_CODE (type);
402
 
403
  /* GCC returns a `long double' in memory too.  */
404
  if (((code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION)
405
       && !m68k_reg_struct_return_p (gdbarch, type))
406
      || (code == TYPE_CODE_FLT && TYPE_LENGTH (type) == 12))
407
    {
408
      /* The default on m68k is to return structures in static memory.
409
         Consequently a function must return the address where we can
410
         find the return value.  */
411
 
412
      if (readbuf)
413
        {
414
          ULONGEST addr;
415
 
416
          regcache_raw_read_unsigned (regcache, M68K_D0_REGNUM, &addr);
417
          read_memory (addr, readbuf, TYPE_LENGTH (type));
418
        }
419
 
420
      return RETURN_VALUE_ABI_RETURNS_ADDRESS;
421
    }
422
 
423
  if (readbuf)
424
    m68k_extract_return_value (type, regcache, readbuf);
425
  if (writebuf)
426
    m68k_store_return_value (type, regcache, writebuf);
427
 
428
  return RETURN_VALUE_REGISTER_CONVENTION;
429
}
430
 
431
static enum return_value_convention
432
m68k_svr4_return_value (struct gdbarch *gdbarch, struct type *func_type,
433
                        struct type *type, struct regcache *regcache,
434
                        gdb_byte *readbuf, const gdb_byte *writebuf)
435
{
436
  enum type_code code = TYPE_CODE (type);
437
 
438
  if ((code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION)
439
      && !m68k_reg_struct_return_p (gdbarch, type))
440
    {
441
      /* The System V ABI says that:
442
 
443
         "A function returning a structure or union also sets %a0 to
444
         the value it finds in %a0.  Thus when the caller receives
445
         control again, the address of the returned object resides in
446
         register %a0."
447
 
448
         So the ABI guarantees that we can always find the return
449
         value just after the function has returned.  */
450
 
451
      if (readbuf)
452
        {
453
          ULONGEST addr;
454
 
455
          regcache_raw_read_unsigned (regcache, M68K_A0_REGNUM, &addr);
456
          read_memory (addr, readbuf, TYPE_LENGTH (type));
457
        }
458
 
459
      return RETURN_VALUE_ABI_RETURNS_ADDRESS;
460
    }
461
 
462
  /* This special case is for structures consisting of a single
463
     `float' or `double' member.  These structures are returned in
464
     %fp0.  For these structures, we call ourselves recursively,
465
     changing TYPE into the type of the first member of the structure.
466
     Since that should work for all structures that have only one
467
     member, we don't bother to check the member's type here.  */
468
  if (code == TYPE_CODE_STRUCT && TYPE_NFIELDS (type) == 1)
469
    {
470
      type = check_typedef (TYPE_FIELD_TYPE (type, 0));
471
      return m68k_svr4_return_value (gdbarch, func_type, type, regcache,
472
                                     readbuf, writebuf);
473
    }
474
 
475
  if (readbuf)
476
    m68k_svr4_extract_return_value (type, regcache, readbuf);
477
  if (writebuf)
478
    m68k_svr4_store_return_value (type, regcache, writebuf);
479
 
480
  return RETURN_VALUE_REGISTER_CONVENTION;
481
}
482
 
483
 
484
/* Always align the frame to a 4-byte boundary.  This is required on
485
   coldfire and harmless on the rest.  */
486
 
487
static CORE_ADDR
488
m68k_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
489
{
490
  /* Align the stack to four bytes.  */
491
  return sp & ~3;
492
}
493
 
494
static CORE_ADDR
495
m68k_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
496
                      struct regcache *regcache, CORE_ADDR bp_addr, int nargs,
497
                      struct value **args, CORE_ADDR sp, int struct_return,
498
                      CORE_ADDR struct_addr)
499
{
500
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
501
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
502
  gdb_byte buf[4];
503
  int i;
504
 
505
  /* Push arguments in reverse order.  */
506
  for (i = nargs - 1; i >= 0; i--)
507
    {
508
      struct type *value_type = value_enclosing_type (args[i]);
509
      int len = TYPE_LENGTH (value_type);
510
      int container_len = (len + 3) & ~3;
511
      int offset;
512
 
513
      /* Non-scalars bigger than 4 bytes are left aligned, others are
514
         right aligned.  */
515
      if ((TYPE_CODE (value_type) == TYPE_CODE_STRUCT
516
           || TYPE_CODE (value_type) == TYPE_CODE_UNION
517
           || TYPE_CODE (value_type) == TYPE_CODE_ARRAY)
518
          && len > 4)
519
        offset = 0;
520
      else
521
        offset = container_len - len;
522
      sp -= container_len;
523
      write_memory (sp + offset, value_contents_all (args[i]), len);
524
    }
525
 
526
  /* Store struct value address.  */
527
  if (struct_return)
528
    {
529
      store_unsigned_integer (buf, 4, byte_order, struct_addr);
530
      regcache_cooked_write (regcache, tdep->struct_value_regnum, buf);
531
    }
532
 
533
  /* Store return address.  */
534
  sp -= 4;
535
  store_unsigned_integer (buf, 4, byte_order, bp_addr);
536
  write_memory (sp, buf, 4);
537
 
538
  /* Finally, update the stack pointer...  */
539
  store_unsigned_integer (buf, 4, byte_order, sp);
540
  regcache_cooked_write (regcache, M68K_SP_REGNUM, buf);
541
 
542
  /* ...and fake a frame pointer.  */
543
  regcache_cooked_write (regcache, M68K_FP_REGNUM, buf);
544
 
545
  /* DWARF2/GCC uses the stack address *before* the function call as a
546
     frame's CFA.  */
547
  return sp + 8;
548
}
549
 
550
/* Convert a dwarf or dwarf2 regnumber to a GDB regnum.  */
551
 
552
static int
553
m68k_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int num)
554
{
555
  if (num < 8)
556
    /* d0..7 */
557
    return (num - 0) + M68K_D0_REGNUM;
558
  else if (num < 16)
559
    /* a0..7 */
560
    return (num - 8) + M68K_A0_REGNUM;
561
  else if (num < 24 && gdbarch_tdep (gdbarch)->fpregs_present)
562
    /* fp0..7 */
563
    return (num - 16) + M68K_FP0_REGNUM;
564
  else if (num == 25)
565
    /* pc */
566
    return M68K_PC_REGNUM;
567
  else
568
    return gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
569
}
570
 
571
 
572
struct m68k_frame_cache
573
{
574
  /* Base address.  */
575
  CORE_ADDR base;
576
  CORE_ADDR sp_offset;
577
  CORE_ADDR pc;
578
 
579
  /* Saved registers.  */
580
  CORE_ADDR saved_regs[M68K_NUM_REGS];
581
  CORE_ADDR saved_sp;
582
 
583
  /* Stack space reserved for local variables.  */
584
  long locals;
585
};
586
 
587
/* Allocate and initialize a frame cache.  */
588
 
589
static struct m68k_frame_cache *
590
m68k_alloc_frame_cache (void)
591
{
592
  struct m68k_frame_cache *cache;
593
  int i;
594
 
595
  cache = FRAME_OBSTACK_ZALLOC (struct m68k_frame_cache);
596
 
597
  /* Base address.  */
598
  cache->base = 0;
599
  cache->sp_offset = -4;
600
  cache->pc = 0;
601
 
602
  /* Saved registers.  We initialize these to -1 since zero is a valid
603
     offset (that's where %fp is supposed to be stored).  */
604
  for (i = 0; i < M68K_NUM_REGS; i++)
605
    cache->saved_regs[i] = -1;
606
 
607
  /* Frameless until proven otherwise.  */
608
  cache->locals = -1;
609
 
610
  return cache;
611
}
612
 
613
/* Check whether PC points at a code that sets up a new stack frame.
614
   If so, it updates CACHE and returns the address of the first
615
   instruction after the sequence that sets removes the "hidden"
616
   argument from the stack or CURRENT_PC, whichever is smaller.
617
   Otherwise, return PC.  */
618
 
619
static CORE_ADDR
620
m68k_analyze_frame_setup (struct gdbarch *gdbarch,
621
                          CORE_ADDR pc, CORE_ADDR current_pc,
622
                          struct m68k_frame_cache *cache)
623
{
624
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
625
  int op;
626
 
627
  if (pc >= current_pc)
628
    return current_pc;
629
 
630
  op = read_memory_unsigned_integer (pc, 2, byte_order);
631
 
632
  if (op == P_LINKW_FP || op == P_LINKL_FP || op == P_PEA_FP)
633
    {
634
      cache->saved_regs[M68K_FP_REGNUM] = 0;
635
      cache->sp_offset += 4;
636
      if (op == P_LINKW_FP)
637
        {
638
          /* link.w %fp, #-N */
639
          /* link.w %fp, #0; adda.l #-N, %sp */
640
          cache->locals = -read_memory_integer (pc + 2, 2, byte_order);
641
 
642
          if (pc + 4 < current_pc && cache->locals == 0)
643
            {
644
              op = read_memory_unsigned_integer (pc + 4, 2, byte_order);
645
              if (op == P_ADDAL_SP)
646
                {
647
                  cache->locals = read_memory_integer (pc + 6, 4, byte_order);
648
                  return pc + 10;
649
                }
650
            }
651
 
652
          return pc + 4;
653
        }
654
      else if (op == P_LINKL_FP)
655
        {
656
          /* link.l %fp, #-N */
657
          cache->locals = -read_memory_integer (pc + 2, 4, byte_order);
658
          return pc + 6;
659
        }
660
      else
661
        {
662
          /* pea (%fp); movea.l %sp, %fp */
663
          cache->locals = 0;
664
 
665
          if (pc + 2 < current_pc)
666
            {
667
              op = read_memory_unsigned_integer (pc + 2, 2, byte_order);
668
 
669
              if (op == P_MOVEAL_SP_FP)
670
                {
671
                  /* move.l %sp, %fp */
672
                  return pc + 4;
673
                }
674
            }
675
 
676
          return pc + 2;
677
        }
678
    }
679
  else if ((op & 0170777) == P_SUBQW_SP || (op & 0170777) == P_SUBQL_SP)
680
    {
681
      /* subq.[wl] #N,%sp */
682
      /* subq.[wl] #8,%sp; subq.[wl] #N,%sp */
683
      cache->locals = (op & 07000) == 0 ? 8 : (op & 07000) >> 9;
684
      if (pc + 2 < current_pc)
685
        {
686
          op = read_memory_unsigned_integer (pc + 2, 2, byte_order);
687
          if ((op & 0170777) == P_SUBQW_SP || (op & 0170777) == P_SUBQL_SP)
688
            {
689
              cache->locals += (op & 07000) == 0 ? 8 : (op & 07000) >> 9;
690
              return pc + 4;
691
            }
692
        }
693
      return pc + 2;
694
    }
695
  else if (op == P_ADDAW_SP || op == P_LEA_SP_SP)
696
    {
697
      /* adda.w #-N,%sp */
698
      /* lea (-N,%sp),%sp */
699
      cache->locals = -read_memory_integer (pc + 2, 2, byte_order);
700
      return pc + 4;
701
    }
702
  else if (op == P_ADDAL_SP)
703
    {
704
      /* adda.l #-N,%sp */
705
      cache->locals = -read_memory_integer (pc + 2, 4, byte_order);
706
      return pc + 6;
707
    }
708
 
709
  return pc;
710
}
711
 
712
/* Check whether PC points at code that saves registers on the stack.
713
   If so, it updates CACHE and returns the address of the first
714
   instruction after the register saves or CURRENT_PC, whichever is
715
   smaller.  Otherwise, return PC.  */
716
 
717
static CORE_ADDR
718
m68k_analyze_register_saves (struct gdbarch *gdbarch, CORE_ADDR pc,
719
                             CORE_ADDR current_pc,
720
                             struct m68k_frame_cache *cache)
721
{
722
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
723
 
724
  if (cache->locals >= 0)
725
    {
726
      CORE_ADDR offset;
727
      int op;
728
      int i, mask, regno;
729
 
730
      offset = -4 - cache->locals;
731
      while (pc < current_pc)
732
        {
733
          op = read_memory_unsigned_integer (pc, 2, byte_order);
734
          if (op == P_FMOVEMX_SP
735
              && gdbarch_tdep (gdbarch)->fpregs_present)
736
            {
737
              /* fmovem.x REGS,-(%sp) */
738
              op = read_memory_unsigned_integer (pc + 2, 2, byte_order);
739
              if ((op & 0xff00) == 0xe000)
740
                {
741
                  mask = op & 0xff;
742
                  for (i = 0; i < 16; i++, mask >>= 1)
743
                    {
744
                      if (mask & 1)
745
                        {
746
                          cache->saved_regs[i + M68K_FP0_REGNUM] = offset;
747
                          offset -= 12;
748
                        }
749
                    }
750
                  pc += 4;
751
                }
752
              else
753
                break;
754
            }
755
          else if ((op & 0177760) == P_MOVEL_SP)
756
            {
757
              /* move.l %R,-(%sp) */
758
              regno = op & 017;
759
              cache->saved_regs[regno] = offset;
760
              offset -= 4;
761
              pc += 2;
762
            }
763
          else if (op == P_MOVEML_SP)
764
            {
765
              /* movem.l REGS,-(%sp) */
766
              mask = read_memory_unsigned_integer (pc + 2, 2, byte_order);
767
              for (i = 0; i < 16; i++, mask >>= 1)
768
                {
769
                  if (mask & 1)
770
                    {
771
                      cache->saved_regs[15 - i] = offset;
772
                      offset -= 4;
773
                    }
774
                }
775
              pc += 4;
776
            }
777
          else
778
            break;
779
        }
780
    }
781
 
782
  return pc;
783
}
784
 
785
 
786
/* Do a full analysis of the prologue at PC and update CACHE
787
   accordingly.  Bail out early if CURRENT_PC is reached.  Return the
788
   address where the analysis stopped.
789
 
790
   We handle all cases that can be generated by gcc.
791
 
792
   For allocating a stack frame:
793
 
794
   link.w %a6,#-N
795
   link.l %a6,#-N
796
   pea (%fp); move.l %sp,%fp
797
   link.w %a6,#0; add.l #-N,%sp
798
   subq.l #N,%sp
799
   subq.w #N,%sp
800
   subq.w #8,%sp; subq.w #N-8,%sp
801
   add.w #-N,%sp
802
   lea (-N,%sp),%sp
803
   add.l #-N,%sp
804
 
805
   For saving registers:
806
 
807
   fmovem.x REGS,-(%sp)
808
   move.l R1,-(%sp)
809
   move.l R1,-(%sp); move.l R2,-(%sp)
810
   movem.l REGS,-(%sp)
811
 
812
   For setting up the PIC register:
813
 
814
   lea (%pc,N),%a5
815
 
816
   */
817
 
818
static CORE_ADDR
819
m68k_analyze_prologue (struct gdbarch *gdbarch, CORE_ADDR pc,
820
                       CORE_ADDR current_pc, struct m68k_frame_cache *cache)
821
{
822
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
823
  unsigned int op;
824
 
825
  pc = m68k_analyze_frame_setup (gdbarch, pc, current_pc, cache);
826
  pc = m68k_analyze_register_saves (gdbarch, pc, current_pc, cache);
827
  if (pc >= current_pc)
828
    return current_pc;
829
 
830
  /* Check for GOT setup.  */
831
  op = read_memory_unsigned_integer (pc, 4, byte_order);
832
  if (op == P_LEA_PC_A5)
833
    {
834
      /* lea (%pc,N),%a5 */
835
      return pc + 8;
836
    }
837
 
838
  return pc;
839
}
840
 
841
/* Return PC of first real instruction.  */
842
 
843
static CORE_ADDR
844
m68k_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc)
845
{
846
  struct m68k_frame_cache cache;
847
  CORE_ADDR pc;
848
  int op;
849
 
850
  cache.locals = -1;
851
  pc = m68k_analyze_prologue (gdbarch, start_pc, (CORE_ADDR) -1, &cache);
852
  if (cache.locals < 0)
853
    return start_pc;
854
  return pc;
855
}
856
 
857
static CORE_ADDR
858
m68k_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
859
{
860
  gdb_byte buf[8];
861
 
862
  frame_unwind_register (next_frame, gdbarch_pc_regnum (gdbarch), buf);
863
  return extract_typed_address (buf, builtin_type (gdbarch)->builtin_func_ptr);
864
}
865
 
866
/* Normal frames.  */
867
 
868
static struct m68k_frame_cache *
869
m68k_frame_cache (struct frame_info *this_frame, void **this_cache)
870
{
871
  struct gdbarch *gdbarch = get_frame_arch (this_frame);
872
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
873
  struct m68k_frame_cache *cache;
874
  gdb_byte buf[4];
875
  int i;
876
 
877
  if (*this_cache)
878
    return *this_cache;
879
 
880
  cache = m68k_alloc_frame_cache ();
881
  *this_cache = cache;
882
 
883
  /* In principle, for normal frames, %fp holds the frame pointer,
884
     which holds the base address for the current stack frame.
885
     However, for functions that don't need it, the frame pointer is
886
     optional.  For these "frameless" functions the frame pointer is
887
     actually the frame pointer of the calling frame.  Signal
888
     trampolines are just a special case of a "frameless" function.
889
     They (usually) share their frame pointer with the frame that was
890
     in progress when the signal occurred.  */
891
 
892
  get_frame_register (this_frame, M68K_FP_REGNUM, buf);
893
  cache->base = extract_unsigned_integer (buf, 4, byte_order);
894
  if (cache->base == 0)
895
    return cache;
896
 
897
  /* For normal frames, %pc is stored at 4(%fp).  */
898
  cache->saved_regs[M68K_PC_REGNUM] = 4;
899
 
900
  cache->pc = get_frame_func (this_frame);
901
  if (cache->pc != 0)
902
    m68k_analyze_prologue (get_frame_arch (this_frame), cache->pc,
903
                           get_frame_pc (this_frame), cache);
904
 
905
  if (cache->locals < 0)
906
    {
907
      /* We didn't find a valid frame, which means that CACHE->base
908
         currently holds the frame pointer for our calling frame.  If
909
         we're at the start of a function, or somewhere half-way its
910
         prologue, the function's frame probably hasn't been fully
911
         setup yet.  Try to reconstruct the base address for the stack
912
         frame by looking at the stack pointer.  For truly "frameless"
913
         functions this might work too.  */
914
 
915
      get_frame_register (this_frame, M68K_SP_REGNUM, buf);
916
      cache->base = extract_unsigned_integer (buf, 4, byte_order)
917
                    + cache->sp_offset;
918
    }
919
 
920
  /* Now that we have the base address for the stack frame we can
921
     calculate the value of %sp in the calling frame.  */
922
  cache->saved_sp = cache->base + 8;
923
 
924
  /* Adjust all the saved registers such that they contain addresses
925
     instead of offsets.  */
926
  for (i = 0; i < M68K_NUM_REGS; i++)
927
    if (cache->saved_regs[i] != -1)
928
      cache->saved_regs[i] += cache->base;
929
 
930
  return cache;
931
}
932
 
933
static void
934
m68k_frame_this_id (struct frame_info *this_frame, void **this_cache,
935
                    struct frame_id *this_id)
936
{
937
  struct m68k_frame_cache *cache = m68k_frame_cache (this_frame, this_cache);
938
 
939
  /* This marks the outermost frame.  */
940
  if (cache->base == 0)
941
    return;
942
 
943
  /* See the end of m68k_push_dummy_call.  */
944
  *this_id = frame_id_build (cache->base + 8, cache->pc);
945
}
946
 
947
static struct value *
948
m68k_frame_prev_register (struct frame_info *this_frame, void **this_cache,
949
                          int regnum)
950
{
951
  struct m68k_frame_cache *cache = m68k_frame_cache (this_frame, this_cache);
952
 
953
  gdb_assert (regnum >= 0);
954
 
955
  if (regnum == M68K_SP_REGNUM && cache->saved_sp)
956
    return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
957
 
958
  if (regnum < M68K_NUM_REGS && cache->saved_regs[regnum] != -1)
959
    return frame_unwind_got_memory (this_frame, regnum,
960
                                    cache->saved_regs[regnum]);
961
 
962
  return frame_unwind_got_register (this_frame, regnum, regnum);
963
}
964
 
965
static const struct frame_unwind m68k_frame_unwind =
966
{
967
  NORMAL_FRAME,
968
  m68k_frame_this_id,
969
  m68k_frame_prev_register,
970
  NULL,
971
  default_frame_sniffer
972
};
973
 
974
static CORE_ADDR
975
m68k_frame_base_address (struct frame_info *this_frame, void **this_cache)
976
{
977
  struct m68k_frame_cache *cache = m68k_frame_cache (this_frame, this_cache);
978
 
979
  return cache->base;
980
}
981
 
982
static const struct frame_base m68k_frame_base =
983
{
984
  &m68k_frame_unwind,
985
  m68k_frame_base_address,
986
  m68k_frame_base_address,
987
  m68k_frame_base_address
988
};
989
 
990
static struct frame_id
991
m68k_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
992
{
993
  CORE_ADDR fp;
994
 
995
  fp = get_frame_register_unsigned (this_frame, M68K_FP_REGNUM);
996
 
997
  /* See the end of m68k_push_dummy_call.  */
998
  return frame_id_build (fp + 8, get_frame_pc (this_frame));
999
}
1000
 
1001
 
1002
/* Figure out where the longjmp will land.  Slurp the args out of the stack.
1003
   We expect the first arg to be a pointer to the jmp_buf structure from which
1004
   we extract the pc (JB_PC) that we will land at.  The pc is copied into PC.
1005
   This routine returns true on success. */
1006
 
1007
static int
1008
m68k_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
1009
{
1010
  gdb_byte *buf;
1011
  CORE_ADDR sp, jb_addr;
1012
  struct gdbarch *gdbarch = get_frame_arch (frame);
1013
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1014
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1015
 
1016
  if (tdep->jb_pc < 0)
1017
    {
1018
      internal_error (__FILE__, __LINE__,
1019
                      _("m68k_get_longjmp_target: not implemented"));
1020
      return 0;
1021
    }
1022
 
1023
  buf = alloca (gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT);
1024
  sp = get_frame_register_unsigned (frame, gdbarch_sp_regnum (gdbarch));
1025
 
1026
  if (target_read_memory (sp + SP_ARG0, /* Offset of first arg on stack */
1027
                          buf, gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT))
1028
    return 0;
1029
 
1030
  jb_addr = extract_unsigned_integer (buf, gdbarch_ptr_bit (gdbarch)
1031
                                             / TARGET_CHAR_BIT, byte_order);
1032
 
1033
  if (target_read_memory (jb_addr + tdep->jb_pc * tdep->jb_elt_size, buf,
1034
                          gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT),
1035
                          byte_order)
1036
    return 0;
1037
 
1038
  *pc = extract_unsigned_integer (buf, gdbarch_ptr_bit (gdbarch)
1039
                                         / TARGET_CHAR_BIT, byte_order);
1040
  return 1;
1041
}
1042
 
1043
 
1044
/* System V Release 4 (SVR4).  */
1045
 
1046
void
1047
m68k_svr4_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1048
{
1049
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1050
 
1051
  /* SVR4 uses a different calling convention.  */
1052
  set_gdbarch_return_value (gdbarch, m68k_svr4_return_value);
1053
 
1054
  /* SVR4 uses %a0 instead of %a1.  */
1055
  tdep->struct_value_regnum = M68K_A0_REGNUM;
1056
}
1057
 
1058
 
1059
/* Function: m68k_gdbarch_init
1060
   Initializer function for the m68k gdbarch vector.
1061
   Called by gdbarch.  Sets up the gdbarch vector(s) for this target. */
1062
 
1063
static struct gdbarch *
1064
m68k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1065
{
1066
  struct gdbarch_tdep *tdep = NULL;
1067
  struct gdbarch *gdbarch;
1068
  struct gdbarch_list *best_arch;
1069
  struct tdesc_arch_data *tdesc_data = NULL;
1070
  int i;
1071
  enum m68k_flavour flavour = m68k_no_flavour;
1072
  int has_fp = 1;
1073
  const struct floatformat **long_double_format = floatformats_m68881_ext;
1074
 
1075
  /* Check any target description for validity.  */
1076
  if (tdesc_has_registers (info.target_desc))
1077
    {
1078
      const struct tdesc_feature *feature;
1079
      int valid_p;
1080
 
1081
      feature = tdesc_find_feature (info.target_desc,
1082
                                    "org.gnu.gdb.m68k.core");
1083
      if (feature != NULL)
1084
        /* Do nothing.  */
1085
        ;
1086
 
1087
      if (feature == NULL)
1088
        {
1089
          feature = tdesc_find_feature (info.target_desc,
1090
                                        "org.gnu.gdb.coldfire.core");
1091
          if (feature != NULL)
1092
            flavour = m68k_coldfire_flavour;
1093
        }
1094
 
1095
      if (feature == NULL)
1096
        {
1097
          feature = tdesc_find_feature (info.target_desc,
1098
                                        "org.gnu.gdb.fido.core");
1099
          if (feature != NULL)
1100
            flavour = m68k_fido_flavour;
1101
        }
1102
 
1103
      if (feature == NULL)
1104
        return NULL;
1105
 
1106
      tdesc_data = tdesc_data_alloc ();
1107
 
1108
      valid_p = 1;
1109
      for (i = 0; i <= M68K_PC_REGNUM; i++)
1110
        valid_p &= tdesc_numbered_register (feature, tdesc_data, i,
1111
                                            m68k_register_names[i]);
1112
 
1113
      if (!valid_p)
1114
        {
1115
          tdesc_data_cleanup (tdesc_data);
1116
          return NULL;
1117
        }
1118
 
1119
      feature = tdesc_find_feature (info.target_desc,
1120
                                    "org.gnu.gdb.coldfire.fp");
1121
      if (feature != NULL)
1122
        {
1123
          valid_p = 1;
1124
          for (i = M68K_FP0_REGNUM; i <= M68K_FPI_REGNUM; i++)
1125
            valid_p &= tdesc_numbered_register (feature, tdesc_data, i,
1126
                                                m68k_register_names[i]);
1127
          if (!valid_p)
1128
            {
1129
              tdesc_data_cleanup (tdesc_data);
1130
              return NULL;
1131
            }
1132
        }
1133
      else
1134
        has_fp = 0;
1135
    }
1136
 
1137
  /* The mechanism for returning floating values from function
1138
     and the type of long double depend on whether we're
1139
     on ColdFire or standard m68k. */
1140
 
1141
  if (info.bfd_arch_info && info.bfd_arch_info->mach != 0)
1142
    {
1143
      const bfd_arch_info_type *coldfire_arch =
1144
        bfd_lookup_arch (bfd_arch_m68k, bfd_mach_mcf_isa_a_nodiv);
1145
 
1146
      if (coldfire_arch
1147
          && ((*info.bfd_arch_info->compatible)
1148
              (info.bfd_arch_info, coldfire_arch)))
1149
        flavour = m68k_coldfire_flavour;
1150
    }
1151
 
1152
  /* If there is already a candidate, use it.  */
1153
  for (best_arch = gdbarch_list_lookup_by_info (arches, &info);
1154
       best_arch != NULL;
1155
       best_arch = gdbarch_list_lookup_by_info (best_arch->next, &info))
1156
    {
1157
      if (flavour != gdbarch_tdep (best_arch->gdbarch)->flavour)
1158
        continue;
1159
 
1160
      if (has_fp != gdbarch_tdep (best_arch->gdbarch)->fpregs_present)
1161
        continue;
1162
 
1163
      break;
1164
    }
1165
 
1166
  if (best_arch != NULL)
1167
    {
1168
      if (tdesc_data != NULL)
1169
        tdesc_data_cleanup (tdesc_data);
1170
      return best_arch->gdbarch;
1171
    }
1172
 
1173
  tdep = xzalloc (sizeof (struct gdbarch_tdep));
1174
  gdbarch = gdbarch_alloc (&info, tdep);
1175
  tdep->fpregs_present = has_fp;
1176
  tdep->flavour = flavour;
1177
 
1178
  if (flavour == m68k_coldfire_flavour || flavour == m68k_fido_flavour)
1179
    long_double_format = floatformats_ieee_double;
1180
  set_gdbarch_long_double_format (gdbarch, long_double_format);
1181
  set_gdbarch_long_double_bit (gdbarch, long_double_format[0]->totalsize);
1182
 
1183
  set_gdbarch_skip_prologue (gdbarch, m68k_skip_prologue);
1184
  set_gdbarch_breakpoint_from_pc (gdbarch, m68k_local_breakpoint_from_pc);
1185
 
1186
  /* Stack grows down. */
1187
  set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1188
  set_gdbarch_frame_align (gdbarch, m68k_frame_align);
1189
 
1190
  set_gdbarch_believe_pcc_promotion (gdbarch, 1);
1191
  if (flavour == m68k_coldfire_flavour || flavour == m68k_fido_flavour)
1192
    set_gdbarch_decr_pc_after_break (gdbarch, 2);
1193
 
1194
  set_gdbarch_frame_args_skip (gdbarch, 8);
1195
  set_gdbarch_dwarf2_reg_to_regnum (gdbarch, m68k_dwarf_reg_to_regnum);
1196
 
1197
  set_gdbarch_register_type (gdbarch, m68k_register_type);
1198
  set_gdbarch_register_name (gdbarch, m68k_register_name);
1199
  set_gdbarch_num_regs (gdbarch, M68K_NUM_REGS);
1200
  set_gdbarch_sp_regnum (gdbarch, M68K_SP_REGNUM);
1201
  set_gdbarch_pc_regnum (gdbarch, M68K_PC_REGNUM);
1202
  set_gdbarch_ps_regnum (gdbarch, M68K_PS_REGNUM);
1203
  set_gdbarch_convert_register_p (gdbarch, m68k_convert_register_p);
1204
  set_gdbarch_register_to_value (gdbarch,  m68k_register_to_value);
1205
  set_gdbarch_value_to_register (gdbarch, m68k_value_to_register);
1206
 
1207
  if (has_fp)
1208
    set_gdbarch_fp0_regnum (gdbarch, M68K_FP0_REGNUM);
1209
 
1210
  /* Try to figure out if the arch uses floating registers to return
1211
     floating point values from functions.  */
1212
  if (has_fp)
1213
    {
1214
      /* On ColdFire, floating point values are returned in D0.  */
1215
      if (flavour == m68k_coldfire_flavour)
1216
        tdep->float_return = 0;
1217
      else
1218
        tdep->float_return = 1;
1219
    }
1220
  else
1221
    {
1222
      /* No floating registers, so can't use them for returning values.  */
1223
      tdep->float_return = 0;
1224
    }
1225
 
1226
  /* Function call & return */
1227
  set_gdbarch_push_dummy_call (gdbarch, m68k_push_dummy_call);
1228
  set_gdbarch_return_value (gdbarch, m68k_return_value);
1229
 
1230
 
1231
  /* Disassembler.  */
1232
  set_gdbarch_print_insn (gdbarch, print_insn_m68k);
1233
 
1234
#if defined JB_PC && defined JB_ELEMENT_SIZE
1235
  tdep->jb_pc = JB_PC;
1236
  tdep->jb_elt_size = JB_ELEMENT_SIZE;
1237
#else
1238
  tdep->jb_pc = -1;
1239
#endif
1240
  tdep->struct_value_regnum = M68K_A1_REGNUM;
1241
  tdep->struct_return = reg_struct_return;
1242
 
1243
  /* Frame unwinder.  */
1244
  set_gdbarch_dummy_id (gdbarch, m68k_dummy_id);
1245
  set_gdbarch_unwind_pc (gdbarch, m68k_unwind_pc);
1246
 
1247
  /* Hook in the DWARF CFI frame unwinder.  */
1248
  dwarf2_append_unwinders (gdbarch);
1249
 
1250
  frame_base_set_default (gdbarch, &m68k_frame_base);
1251
 
1252
  /* Hook in ABI-specific overrides, if they have been registered.  */
1253
  gdbarch_init_osabi (info, gdbarch);
1254
 
1255
  /* Now we have tuned the configuration, set a few final things,
1256
     based on what the OS ABI has told us.  */
1257
 
1258
  if (tdep->jb_pc >= 0)
1259
    set_gdbarch_get_longjmp_target (gdbarch, m68k_get_longjmp_target);
1260
 
1261
  frame_unwind_append_unwinder (gdbarch, &m68k_frame_unwind);
1262
 
1263
  if (tdesc_data)
1264
    tdesc_use_registers (gdbarch, info.target_desc, tdesc_data);
1265
 
1266
  return gdbarch;
1267
}
1268
 
1269
 
1270
static void
1271
m68k_dump_tdep (struct gdbarch *gdbarch, struct ui_file *file)
1272
{
1273
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1274
 
1275
  if (tdep == NULL)
1276
    return;
1277
}
1278
 
1279
extern initialize_file_ftype _initialize_m68k_tdep; /* -Wmissing-prototypes */
1280
 
1281
void
1282
_initialize_m68k_tdep (void)
1283
{
1284
  gdbarch_register (bfd_arch_m68k, m68k_gdbarch_init, m68k_dump_tdep);
1285
}

powered by: WebSVN 2.1.0

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