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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [gdb/] [alpha-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 ALPHA architecture, for GDB, the GNU Debugger.
2
 
3
   Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
4
   2003, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
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 3 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, see <http://www.gnu.org/licenses/>.  */
20
 
21
#include "defs.h"
22
#include "doublest.h"
23
#include "frame.h"
24
#include "frame-unwind.h"
25
#include "frame-base.h"
26
#include "dwarf2-frame.h"
27
#include "inferior.h"
28
#include "symtab.h"
29
#include "value.h"
30
#include "gdbcmd.h"
31
#include "gdbcore.h"
32
#include "dis-asm.h"
33
#include "symfile.h"
34
#include "objfiles.h"
35
#include "gdb_string.h"
36
#include "linespec.h"
37
#include "regcache.h"
38
#include "reggroups.h"
39
#include "arch-utils.h"
40
#include "osabi.h"
41
#include "block.h"
42
#include "infcall.h"
43
#include "trad-frame.h"
44
 
45
#include "elf-bfd.h"
46
 
47
#include "alpha-tdep.h"
48
 
49
 
50
/* Return the name of the REGNO register.
51
 
52
   An empty name corresponds to a register number that used to
53
   be used for a virtual register. That virtual register has
54
   been removed, but the index is still reserved to maintain
55
   compatibility with existing remote alpha targets.  */
56
 
57
static const char *
58
alpha_register_name (struct gdbarch *gdbarch, int regno)
59
{
60
  static const char * const register_names[] =
61
  {
62
    "v0",   "t0",   "t1",   "t2",   "t3",   "t4",   "t5",   "t6",
63
    "t7",   "s0",   "s1",   "s2",   "s3",   "s4",   "s5",   "fp",
64
    "a0",   "a1",   "a2",   "a3",   "a4",   "a5",   "t8",   "t9",
65
    "t10",  "t11",  "ra",   "t12",  "at",   "gp",   "sp",   "zero",
66
    "f0",   "f1",   "f2",   "f3",   "f4",   "f5",   "f6",   "f7",
67
    "f8",   "f9",   "f10",  "f11",  "f12",  "f13",  "f14",  "f15",
68
    "f16",  "f17",  "f18",  "f19",  "f20",  "f21",  "f22",  "f23",
69
    "f24",  "f25",  "f26",  "f27",  "f28",  "f29",  "f30",  "fpcr",
70
    "pc",   "",     "unique"
71
  };
72
 
73
  if (regno < 0)
74
    return NULL;
75
  if (regno >= ARRAY_SIZE(register_names))
76
    return NULL;
77
  return register_names[regno];
78
}
79
 
80
static int
81
alpha_cannot_fetch_register (struct gdbarch *gdbarch, int regno)
82
{
83
  return (regno == ALPHA_ZERO_REGNUM
84
          || strlen (alpha_register_name (gdbarch, regno)) == 0);
85
}
86
 
87
static int
88
alpha_cannot_store_register (struct gdbarch *gdbarch, int regno)
89
{
90
  return (regno == ALPHA_ZERO_REGNUM
91
          || strlen (alpha_register_name (gdbarch, regno)) == 0);
92
}
93
 
94
static struct type *
95
alpha_register_type (struct gdbarch *gdbarch, int regno)
96
{
97
  if (regno == ALPHA_SP_REGNUM || regno == ALPHA_GP_REGNUM)
98
    return builtin_type (gdbarch)->builtin_data_ptr;
99
  if (regno == ALPHA_PC_REGNUM)
100
    return builtin_type (gdbarch)->builtin_func_ptr;
101
 
102
  /* Don't need to worry about little vs big endian until
103
     some jerk tries to port to alpha-unicosmk.  */
104
  if (regno >= ALPHA_FP0_REGNUM && regno < ALPHA_FP0_REGNUM + 31)
105
    return builtin_type (gdbarch)->builtin_double;
106
 
107
  return builtin_type (gdbarch)->builtin_int64;
108
}
109
 
110
/* Is REGNUM a member of REGGROUP?  */
111
 
112
static int
113
alpha_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
114
                           struct reggroup *group)
115
{
116
  /* Filter out any registers eliminated, but whose regnum is
117
     reserved for backward compatibility, e.g. the vfp.  */
118
  if (gdbarch_register_name (gdbarch, regnum) == NULL
119
      || *gdbarch_register_name (gdbarch, regnum) == '\0')
120
    return 0;
121
 
122
  if (group == all_reggroup)
123
    return 1;
124
 
125
  /* Zero should not be saved or restored.  Technically it is a general
126
     register (just as $f31 would be a float if we represented it), but
127
     there's no point displaying it during "info regs", so leave it out
128
     of all groups except for "all".  */
129
  if (regnum == ALPHA_ZERO_REGNUM)
130
    return 0;
131
 
132
  /* All other registers are saved and restored.  */
133
  if (group == save_reggroup || group == restore_reggroup)
134
    return 1;
135
 
136
  /* All other groups are non-overlapping.  */
137
 
138
  /* Since this is really a PALcode memory slot...  */
139
  if (regnum == ALPHA_UNIQUE_REGNUM)
140
    return group == system_reggroup;
141
 
142
  /* Force the FPCR to be considered part of the floating point state.  */
143
  if (regnum == ALPHA_FPCR_REGNUM)
144
    return group == float_reggroup;
145
 
146
  if (regnum >= ALPHA_FP0_REGNUM && regnum < ALPHA_FP0_REGNUM + 31)
147
    return group == float_reggroup;
148
  else
149
    return group == general_reggroup;
150
}
151
 
152
/* The following represents exactly the conversion performed by
153
   the LDS instruction.  This applies to both single-precision
154
   floating point and 32-bit integers.  */
155
 
156
static void
157
alpha_lds (struct gdbarch *gdbarch, void *out, const void *in)
158
{
159
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
160
  ULONGEST mem     = extract_unsigned_integer (in, 4, byte_order);
161
  ULONGEST frac    = (mem >>  0) & 0x7fffff;
162
  ULONGEST sign    = (mem >> 31) & 1;
163
  ULONGEST exp_msb = (mem >> 30) & 1;
164
  ULONGEST exp_low = (mem >> 23) & 0x7f;
165
  ULONGEST exp, reg;
166
 
167
  exp = (exp_msb << 10) | exp_low;
168
  if (exp_msb)
169
    {
170
      if (exp_low == 0x7f)
171
        exp = 0x7ff;
172
    }
173
  else
174
    {
175
      if (exp_low != 0x00)
176
        exp |= 0x380;
177
    }
178
 
179
  reg = (sign << 63) | (exp << 52) | (frac << 29);
180
  store_unsigned_integer (out, 8, byte_order, reg);
181
}
182
 
183
/* Similarly, this represents exactly the conversion performed by
184
   the STS instruction.  */
185
 
186
static void
187
alpha_sts (struct gdbarch *gdbarch, void *out, const void *in)
188
{
189
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
190
  ULONGEST reg, mem;
191
 
192
  reg = extract_unsigned_integer (in, 8, byte_order);
193
  mem = ((reg >> 32) & 0xc0000000) | ((reg >> 29) & 0x3fffffff);
194
  store_unsigned_integer (out, 4, byte_order, mem);
195
}
196
 
197
/* The alpha needs a conversion between register and memory format if the
198
   register is a floating point register and memory format is float, as the
199
   register format must be double or memory format is an integer with 4
200
   bytes or less, as the representation of integers in floating point
201
   registers is different. */
202
 
203
static int
204
alpha_convert_register_p (struct gdbarch *gdbarch, int regno, struct type *type)
205
{
206
  return (regno >= ALPHA_FP0_REGNUM && regno < ALPHA_FP0_REGNUM + 31
207
          && TYPE_LENGTH (type) != 8);
208
}
209
 
210
static void
211
alpha_register_to_value (struct frame_info *frame, int regnum,
212
                         struct type *valtype, gdb_byte *out)
213
{
214
  gdb_byte in[MAX_REGISTER_SIZE];
215
 
216
  frame_register_read (frame, regnum, in);
217
  switch (TYPE_LENGTH (valtype))
218
    {
219
    case 4:
220
      alpha_sts (get_frame_arch (frame), out, in);
221
      break;
222
    default:
223
      error (_("Cannot retrieve value from floating point register"));
224
    }
225
}
226
 
227
static void
228
alpha_value_to_register (struct frame_info *frame, int regnum,
229
                         struct type *valtype, const gdb_byte *in)
230
{
231
  gdb_byte out[MAX_REGISTER_SIZE];
232
 
233
  switch (TYPE_LENGTH (valtype))
234
    {
235
    case 4:
236
      alpha_lds (get_frame_arch (frame), out, in);
237
      break;
238
    default:
239
      error (_("Cannot store value in floating point register"));
240
    }
241
  put_frame_register (frame, regnum, out);
242
}
243
 
244
 
245
/* The alpha passes the first six arguments in the registers, the rest on
246
   the stack.  The register arguments are stored in ARG_REG_BUFFER, and
247
   then moved into the register file; this simplifies the passing of a
248
   large struct which extends from the registers to the stack, plus avoids
249
   three ptrace invocations per word.
250
 
251
   We don't bother tracking which register values should go in integer
252
   regs or fp regs; we load the same values into both.
253
 
254
   If the called function is returning a structure, the address of the
255
   structure to be returned is passed as a hidden first argument.  */
256
 
257
static CORE_ADDR
258
alpha_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
259
                       struct regcache *regcache, CORE_ADDR bp_addr,
260
                       int nargs, struct value **args, CORE_ADDR sp,
261
                       int struct_return, CORE_ADDR struct_addr)
262
{
263
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
264
  int i;
265
  int accumulate_size = struct_return ? 8 : 0;
266
  struct alpha_arg
267
    {
268
      gdb_byte *contents;
269
      int len;
270
      int offset;
271
    };
272
  struct alpha_arg *alpha_args
273
    = (struct alpha_arg *) alloca (nargs * sizeof (struct alpha_arg));
274
  struct alpha_arg *m_arg;
275
  gdb_byte arg_reg_buffer[ALPHA_REGISTER_SIZE * ALPHA_NUM_ARG_REGS];
276
  int required_arg_regs;
277
  CORE_ADDR func_addr = find_function_addr (function, NULL);
278
 
279
  /* The ABI places the address of the called function in T12.  */
280
  regcache_cooked_write_signed (regcache, ALPHA_T12_REGNUM, func_addr);
281
 
282
  /* Set the return address register to point to the entry point
283
     of the program, where a breakpoint lies in wait.  */
284
  regcache_cooked_write_signed (regcache, ALPHA_RA_REGNUM, bp_addr);
285
 
286
  /* Lay out the arguments in memory.  */
287
  for (i = 0, m_arg = alpha_args; i < nargs; i++, m_arg++)
288
    {
289
      struct value *arg = args[i];
290
      struct type *arg_type = check_typedef (value_type (arg));
291
 
292
      /* Cast argument to long if necessary as the compiler does it too.  */
293
      switch (TYPE_CODE (arg_type))
294
        {
295
        case TYPE_CODE_INT:
296
        case TYPE_CODE_BOOL:
297
        case TYPE_CODE_CHAR:
298
        case TYPE_CODE_RANGE:
299
        case TYPE_CODE_ENUM:
300
          if (TYPE_LENGTH (arg_type) == 4)
301
            {
302
              /* 32-bit values must be sign-extended to 64 bits
303
                 even if the base data type is unsigned.  */
304
              arg_type = builtin_type (gdbarch)->builtin_int32;
305
              arg = value_cast (arg_type, arg);
306
            }
307
          if (TYPE_LENGTH (arg_type) < ALPHA_REGISTER_SIZE)
308
            {
309
              arg_type = builtin_type (gdbarch)->builtin_int64;
310
              arg = value_cast (arg_type, arg);
311
            }
312
          break;
313
 
314
        case TYPE_CODE_FLT:
315
          /* "float" arguments loaded in registers must be passed in
316
             register format, aka "double".  */
317
          if (accumulate_size < sizeof (arg_reg_buffer)
318
              && TYPE_LENGTH (arg_type) == 4)
319
            {
320
              arg_type = builtin_type (gdbarch)->builtin_double;
321
              arg = value_cast (arg_type, arg);
322
            }
323
          /* Tru64 5.1 has a 128-bit long double, and passes this by
324
             invisible reference.  No one else uses this data type.  */
325
          else if (TYPE_LENGTH (arg_type) == 16)
326
            {
327
              /* Allocate aligned storage.  */
328
              sp = (sp & -16) - 16;
329
 
330
              /* Write the real data into the stack.  */
331
              write_memory (sp, value_contents (arg), 16);
332
 
333
              /* Construct the indirection.  */
334
              arg_type = lookup_pointer_type (arg_type);
335
              arg = value_from_pointer (arg_type, sp);
336
            }
337
          break;
338
 
339
        case TYPE_CODE_COMPLEX:
340
          /* ??? The ABI says that complex values are passed as two
341
             separate scalar values.  This distinction only matters
342
             for complex float.  However, GCC does not implement this.  */
343
 
344
          /* Tru64 5.1 has a 128-bit long double, and passes this by
345
             invisible reference.  */
346
          if (TYPE_LENGTH (arg_type) == 32)
347
            {
348
              /* Allocate aligned storage.  */
349
              sp = (sp & -16) - 16;
350
 
351
              /* Write the real data into the stack.  */
352
              write_memory (sp, value_contents (arg), 32);
353
 
354
              /* Construct the indirection.  */
355
              arg_type = lookup_pointer_type (arg_type);
356
              arg = value_from_pointer (arg_type, sp);
357
            }
358
          break;
359
 
360
        default:
361
          break;
362
        }
363
      m_arg->len = TYPE_LENGTH (arg_type);
364
      m_arg->offset = accumulate_size;
365
      accumulate_size = (accumulate_size + m_arg->len + 7) & ~7;
366
      m_arg->contents = value_contents_writeable (arg);
367
    }
368
 
369
  /* Determine required argument register loads, loading an argument register
370
     is expensive as it uses three ptrace calls.  */
371
  required_arg_regs = accumulate_size / 8;
372
  if (required_arg_regs > ALPHA_NUM_ARG_REGS)
373
    required_arg_regs = ALPHA_NUM_ARG_REGS;
374
 
375
  /* Make room for the arguments on the stack.  */
376
  if (accumulate_size < sizeof(arg_reg_buffer))
377
    accumulate_size = 0;
378
  else
379
    accumulate_size -= sizeof(arg_reg_buffer);
380
  sp -= accumulate_size;
381
 
382
  /* Keep sp aligned to a multiple of 16 as the ABI requires.  */
383
  sp &= ~15;
384
 
385
  /* `Push' arguments on the stack.  */
386
  for (i = nargs; m_arg--, --i >= 0;)
387
    {
388
      gdb_byte *contents = m_arg->contents;
389
      int offset = m_arg->offset;
390
      int len = m_arg->len;
391
 
392
      /* Copy the bytes destined for registers into arg_reg_buffer.  */
393
      if (offset < sizeof(arg_reg_buffer))
394
        {
395
          if (offset + len <= sizeof(arg_reg_buffer))
396
            {
397
              memcpy (arg_reg_buffer + offset, contents, len);
398
              continue;
399
            }
400
          else
401
            {
402
              int tlen = sizeof(arg_reg_buffer) - offset;
403
              memcpy (arg_reg_buffer + offset, contents, tlen);
404
              offset += tlen;
405
              contents += tlen;
406
              len -= tlen;
407
            }
408
        }
409
 
410
      /* Everything else goes to the stack.  */
411
      write_memory (sp + offset - sizeof(arg_reg_buffer), contents, len);
412
    }
413
  if (struct_return)
414
    store_unsigned_integer (arg_reg_buffer, ALPHA_REGISTER_SIZE,
415
                            byte_order, struct_addr);
416
 
417
  /* Load the argument registers.  */
418
  for (i = 0; i < required_arg_regs; i++)
419
    {
420
      regcache_cooked_write (regcache, ALPHA_A0_REGNUM + i,
421
                             arg_reg_buffer + i*ALPHA_REGISTER_SIZE);
422
      regcache_cooked_write (regcache, ALPHA_FPA0_REGNUM + i,
423
                             arg_reg_buffer + i*ALPHA_REGISTER_SIZE);
424
    }
425
 
426
  /* Finally, update the stack pointer.  */
427
  regcache_cooked_write_signed (regcache, ALPHA_SP_REGNUM, sp);
428
 
429
  return sp;
430
}
431
 
432
/* Extract from REGCACHE the value about to be returned from a function
433
   and copy it into VALBUF.  */
434
 
435
static void
436
alpha_extract_return_value (struct type *valtype, struct regcache *regcache,
437
                            gdb_byte *valbuf)
438
{
439
  struct gdbarch *gdbarch = get_regcache_arch (regcache);
440
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
441
  int length = TYPE_LENGTH (valtype);
442
  gdb_byte raw_buffer[ALPHA_REGISTER_SIZE];
443
  ULONGEST l;
444
 
445
  switch (TYPE_CODE (valtype))
446
    {
447
    case TYPE_CODE_FLT:
448
      switch (length)
449
        {
450
        case 4:
451
          regcache_cooked_read (regcache, ALPHA_FP0_REGNUM, raw_buffer);
452
          alpha_sts (gdbarch, valbuf, raw_buffer);
453
          break;
454
 
455
        case 8:
456
          regcache_cooked_read (regcache, ALPHA_FP0_REGNUM, valbuf);
457
          break;
458
 
459
        case 16:
460
          regcache_cooked_read_unsigned (regcache, ALPHA_V0_REGNUM, &l);
461
          read_memory (l, valbuf, 16);
462
          break;
463
 
464
        default:
465
          internal_error (__FILE__, __LINE__, _("unknown floating point width"));
466
        }
467
      break;
468
 
469
    case TYPE_CODE_COMPLEX:
470
      switch (length)
471
        {
472
        case 8:
473
          /* ??? This isn't correct wrt the ABI, but it's what GCC does.  */
474
          regcache_cooked_read (regcache, ALPHA_FP0_REGNUM, valbuf);
475
          break;
476
 
477
        case 16:
478
          regcache_cooked_read (regcache, ALPHA_FP0_REGNUM, valbuf);
479
          regcache_cooked_read (regcache, ALPHA_FP0_REGNUM + 1, valbuf + 8);
480
          break;
481
 
482
        case 32:
483
          regcache_cooked_read_signed (regcache, ALPHA_V0_REGNUM, &l);
484
          read_memory (l, valbuf, 32);
485
          break;
486
 
487
        default:
488
          internal_error (__FILE__, __LINE__, _("unknown floating point width"));
489
        }
490
      break;
491
 
492
    default:
493
      /* Assume everything else degenerates to an integer.  */
494
      regcache_cooked_read_unsigned (regcache, ALPHA_V0_REGNUM, &l);
495
      store_unsigned_integer (valbuf, length, byte_order, l);
496
      break;
497
    }
498
}
499
 
500
/* Insert the given value into REGCACHE as if it was being
501
   returned by a function.  */
502
 
503
static void
504
alpha_store_return_value (struct type *valtype, struct regcache *regcache,
505
                          const gdb_byte *valbuf)
506
{
507
  struct gdbarch *gdbarch = get_regcache_arch (regcache);
508
  int length = TYPE_LENGTH (valtype);
509
  gdb_byte raw_buffer[ALPHA_REGISTER_SIZE];
510
  ULONGEST l;
511
 
512
  switch (TYPE_CODE (valtype))
513
    {
514
    case TYPE_CODE_FLT:
515
      switch (length)
516
        {
517
        case 4:
518
          alpha_lds (gdbarch, raw_buffer, valbuf);
519
          regcache_cooked_write (regcache, ALPHA_FP0_REGNUM, raw_buffer);
520
          break;
521
 
522
        case 8:
523
          regcache_cooked_write (regcache, ALPHA_FP0_REGNUM, valbuf);
524
          break;
525
 
526
        case 16:
527
          /* FIXME: 128-bit long doubles are returned like structures:
528
             by writing into indirect storage provided by the caller
529
             as the first argument.  */
530
          error (_("Cannot set a 128-bit long double return value."));
531
 
532
        default:
533
          internal_error (__FILE__, __LINE__, _("unknown floating point width"));
534
        }
535
      break;
536
 
537
    case TYPE_CODE_COMPLEX:
538
      switch (length)
539
        {
540
        case 8:
541
          /* ??? This isn't correct wrt the ABI, but it's what GCC does.  */
542
          regcache_cooked_write (regcache, ALPHA_FP0_REGNUM, valbuf);
543
          break;
544
 
545
        case 16:
546
          regcache_cooked_write (regcache, ALPHA_FP0_REGNUM, valbuf);
547
          regcache_cooked_write (regcache, ALPHA_FP0_REGNUM + 1, valbuf + 8);
548
          break;
549
 
550
        case 32:
551
          /* FIXME: 128-bit long doubles are returned like structures:
552
             by writing into indirect storage provided by the caller
553
             as the first argument.  */
554
          error (_("Cannot set a 128-bit long double return value."));
555
 
556
        default:
557
          internal_error (__FILE__, __LINE__, _("unknown floating point width"));
558
        }
559
      break;
560
 
561
    default:
562
      /* Assume everything else degenerates to an integer.  */
563
      /* 32-bit values must be sign-extended to 64 bits
564
         even if the base data type is unsigned.  */
565
      if (length == 4)
566
        valtype = builtin_type (gdbarch)->builtin_int32;
567
      l = unpack_long (valtype, valbuf);
568
      regcache_cooked_write_unsigned (regcache, ALPHA_V0_REGNUM, l);
569
      break;
570
    }
571
}
572
 
573
static enum return_value_convention
574
alpha_return_value (struct gdbarch *gdbarch, struct type *func_type,
575
                    struct type *type, struct regcache *regcache,
576
                    gdb_byte *readbuf, const gdb_byte *writebuf)
577
{
578
  enum type_code code = TYPE_CODE (type);
579
 
580
  if ((code == TYPE_CODE_STRUCT
581
       || code == TYPE_CODE_UNION
582
       || code == TYPE_CODE_ARRAY)
583
      && gdbarch_tdep (gdbarch)->return_in_memory (type))
584
    {
585
      if (readbuf)
586
        {
587
          ULONGEST addr;
588
          regcache_raw_read_unsigned (regcache, ALPHA_V0_REGNUM, &addr);
589
          read_memory (addr, readbuf, TYPE_LENGTH (type));
590
        }
591
 
592
      return RETURN_VALUE_ABI_RETURNS_ADDRESS;
593
    }
594
 
595
  if (readbuf)
596
    alpha_extract_return_value (type, regcache, readbuf);
597
  if (writebuf)
598
    alpha_store_return_value (type, regcache, writebuf);
599
 
600
  return RETURN_VALUE_REGISTER_CONVENTION;
601
}
602
 
603
static int
604
alpha_return_in_memory_always (struct type *type)
605
{
606
  return 1;
607
}
608
 
609
static const gdb_byte *
610
alpha_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pc, int *len)
611
{
612
  static const gdb_byte break_insn[] = { 0x80, 0, 0, 0 }; /* call_pal bpt */
613
 
614
  *len = sizeof(break_insn);
615
  return break_insn;
616
}
617
 
618
 
619
/* This returns the PC of the first insn after the prologue.
620
   If we can't find the prologue, then return 0.  */
621
 
622
CORE_ADDR
623
alpha_after_prologue (CORE_ADDR pc)
624
{
625
  struct symtab_and_line sal;
626
  CORE_ADDR func_addr, func_end;
627
 
628
  if (!find_pc_partial_function (pc, NULL, &func_addr, &func_end))
629
    return 0;
630
 
631
  sal = find_pc_line (func_addr, 0);
632
  if (sal.end < func_end)
633
    return sal.end;
634
 
635
  /* The line after the prologue is after the end of the function.  In this
636
     case, tell the caller to find the prologue the hard way.  */
637
  return 0;
638
}
639
 
640
/* Read an instruction from memory at PC, looking through breakpoints.  */
641
 
642
unsigned int
643
alpha_read_insn (struct gdbarch *gdbarch, CORE_ADDR pc)
644
{
645
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
646
  gdb_byte buf[ALPHA_INSN_SIZE];
647
  int status;
648
 
649
  status = target_read_memory (pc, buf, sizeof (buf));
650
  if (status)
651
    memory_error (status, pc);
652
  return extract_unsigned_integer (buf, sizeof (buf), byte_order);
653
}
654
 
655
/* To skip prologues, I use this predicate.  Returns either PC itself
656
   if the code at PC does not look like a function prologue; otherwise
657
   returns an address that (if we're lucky) follows the prologue.  If
658
   LENIENT, then we must skip everything which is involved in setting
659
   up the frame (it's OK to skip more, just so long as we don't skip
660
   anything which might clobber the registers which are being saved.  */
661
 
662
static CORE_ADDR
663
alpha_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
664
{
665
  unsigned long inst;
666
  int offset;
667
  CORE_ADDR post_prologue_pc;
668
  gdb_byte buf[ALPHA_INSN_SIZE];
669
 
670
  /* Silently return the unaltered pc upon memory errors.
671
     This could happen on OSF/1 if decode_line_1 tries to skip the
672
     prologue for quickstarted shared library functions when the
673
     shared library is not yet mapped in.
674
     Reading target memory is slow over serial lines, so we perform
675
     this check only if the target has shared libraries (which all
676
     Alpha targets do).  */
677
  if (target_read_memory (pc, buf, sizeof (buf)))
678
    return pc;
679
 
680
  /* See if we can determine the end of the prologue via the symbol table.
681
     If so, then return either PC, or the PC after the prologue, whichever
682
     is greater.  */
683
 
684
  post_prologue_pc = alpha_after_prologue (pc);
685
  if (post_prologue_pc != 0)
686
    return max (pc, post_prologue_pc);
687
 
688
  /* Can't determine prologue from the symbol table, need to examine
689
     instructions.  */
690
 
691
  /* Skip the typical prologue instructions. These are the stack adjustment
692
     instruction and the instructions that save registers on the stack
693
     or in the gcc frame.  */
694
  for (offset = 0; offset < 100; offset += ALPHA_INSN_SIZE)
695
    {
696
      inst = alpha_read_insn (gdbarch, pc + offset);
697
 
698
      if ((inst & 0xffff0000) == 0x27bb0000)    /* ldah $gp,n($t12) */
699
        continue;
700
      if ((inst & 0xffff0000) == 0x23bd0000)    /* lda $gp,n($gp) */
701
        continue;
702
      if ((inst & 0xffff0000) == 0x23de0000)    /* lda $sp,n($sp) */
703
        continue;
704
      if ((inst & 0xffe01fff) == 0x43c0153e)    /* subq $sp,n,$sp */
705
        continue;
706
 
707
      if (((inst & 0xfc1f0000) == 0xb41e0000            /* stq reg,n($sp) */
708
           || (inst & 0xfc1f0000) == 0x9c1e0000)        /* stt reg,n($sp) */
709
          && (inst & 0x03e00000) != 0x03e00000)         /* reg != $zero */
710
        continue;
711
 
712
      if (inst == 0x47de040f)                   /* bis sp,sp,fp */
713
        continue;
714
      if (inst == 0x47fe040f)                   /* bis zero,sp,fp */
715
        continue;
716
 
717
      break;
718
    }
719
  return pc + offset;
720
}
721
 
722
 
723
/* Figure out where the longjmp will land.
724
   We expect the first arg to be a pointer to the jmp_buf structure from
725
   which we extract the PC (JB_PC) that we will land at.  The PC is copied
726
   into the "pc".  This routine returns true on success.  */
727
 
728
static int
729
alpha_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
730
{
731
  struct gdbarch *gdbarch = get_frame_arch (frame);
732
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
733
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
734
  CORE_ADDR jb_addr;
735
  gdb_byte raw_buffer[ALPHA_REGISTER_SIZE];
736
 
737
  jb_addr = get_frame_register_unsigned (frame, ALPHA_A0_REGNUM);
738
 
739
  if (target_read_memory (jb_addr + (tdep->jb_pc * tdep->jb_elt_size),
740
                          raw_buffer, tdep->jb_elt_size))
741
    return 0;
742
 
743
  *pc = extract_unsigned_integer (raw_buffer, tdep->jb_elt_size, byte_order);
744
  return 1;
745
}
746
 
747
 
748
/* Frame unwinder for signal trampolines.  We use alpha tdep bits that
749
   describe the location and shape of the sigcontext structure.  After
750
   that, all registers are in memory, so it's easy.  */
751
/* ??? Shouldn't we be able to do this generically, rather than with
752
   OSABI data specific to Alpha?  */
753
 
754
struct alpha_sigtramp_unwind_cache
755
{
756
  CORE_ADDR sigcontext_addr;
757
};
758
 
759
static struct alpha_sigtramp_unwind_cache *
760
alpha_sigtramp_frame_unwind_cache (struct frame_info *this_frame,
761
                                   void **this_prologue_cache)
762
{
763
  struct alpha_sigtramp_unwind_cache *info;
764
  struct gdbarch_tdep *tdep;
765
 
766
  if (*this_prologue_cache)
767
    return *this_prologue_cache;
768
 
769
  info = FRAME_OBSTACK_ZALLOC (struct alpha_sigtramp_unwind_cache);
770
  *this_prologue_cache = info;
771
 
772
  tdep = gdbarch_tdep (get_frame_arch (this_frame));
773
  info->sigcontext_addr = tdep->sigcontext_addr (this_frame);
774
 
775
  return info;
776
}
777
 
778
/* Return the address of REGNUM in a sigtramp frame.  Since this is
779
   all arithmetic, it doesn't seem worthwhile to cache it.  */
780
 
781
static CORE_ADDR
782
alpha_sigtramp_register_address (struct gdbarch *gdbarch,
783
                                 CORE_ADDR sigcontext_addr, int regnum)
784
{
785
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
786
 
787
  if (regnum >= 0 && regnum < 32)
788
    return sigcontext_addr + tdep->sc_regs_offset + regnum * 8;
789
  else if (regnum >= ALPHA_FP0_REGNUM && regnum < ALPHA_FP0_REGNUM + 32)
790
    return sigcontext_addr + tdep->sc_fpregs_offset + regnum * 8;
791
  else if (regnum == ALPHA_PC_REGNUM)
792
    return sigcontext_addr + tdep->sc_pc_offset;
793
 
794
  return 0;
795
}
796
 
797
/* Given a GDB frame, determine the address of the calling function's
798
   frame.  This will be used to create a new GDB frame struct.  */
799
 
800
static void
801
alpha_sigtramp_frame_this_id (struct frame_info *this_frame,
802
                              void **this_prologue_cache,
803
                              struct frame_id *this_id)
804
{
805
  struct gdbarch *gdbarch = get_frame_arch (this_frame);
806
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
807
  struct alpha_sigtramp_unwind_cache *info
808
    = alpha_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
809
  CORE_ADDR stack_addr, code_addr;
810
 
811
  /* If the OSABI couldn't locate the sigcontext, give up.  */
812
  if (info->sigcontext_addr == 0)
813
    return;
814
 
815
  /* If we have dynamic signal trampolines, find their start.
816
     If we do not, then we must assume there is a symbol record
817
     that can provide the start address.  */
818
  if (tdep->dynamic_sigtramp_offset)
819
    {
820
      int offset;
821
      code_addr = get_frame_pc (this_frame);
822
      offset = tdep->dynamic_sigtramp_offset (gdbarch, code_addr);
823
      if (offset >= 0)
824
        code_addr -= offset;
825
      else
826
        code_addr = 0;
827
    }
828
  else
829
    code_addr = get_frame_func (this_frame);
830
 
831
  /* The stack address is trivially read from the sigcontext.  */
832
  stack_addr = alpha_sigtramp_register_address (gdbarch, info->sigcontext_addr,
833
                                                ALPHA_SP_REGNUM);
834
  stack_addr = get_frame_memory_unsigned (this_frame, stack_addr,
835
                                          ALPHA_REGISTER_SIZE);
836
 
837
  *this_id = frame_id_build (stack_addr, code_addr);
838
}
839
 
840
/* Retrieve the value of REGNUM in FRAME.  Don't give up!  */
841
 
842
static struct value *
843
alpha_sigtramp_frame_prev_register (struct frame_info *this_frame,
844
                                    void **this_prologue_cache, int regnum)
845
{
846
  struct alpha_sigtramp_unwind_cache *info
847
    = alpha_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
848
  CORE_ADDR addr;
849
 
850
  if (info->sigcontext_addr != 0)
851
    {
852
      /* All integer and fp registers are stored in memory.  */
853
      addr = alpha_sigtramp_register_address (get_frame_arch (this_frame),
854
                                              info->sigcontext_addr, regnum);
855
      if (addr != 0)
856
        return frame_unwind_got_memory (this_frame, regnum, addr);
857
    }
858
 
859
  /* This extra register may actually be in the sigcontext, but our
860
     current description of it in alpha_sigtramp_frame_unwind_cache
861
     doesn't include it.  Too bad.  Fall back on whatever's in the
862
     outer frame.  */
863
  return frame_unwind_got_register (this_frame, regnum, regnum);
864
}
865
 
866
static int
867
alpha_sigtramp_frame_sniffer (const struct frame_unwind *self,
868
                              struct frame_info *this_frame,
869
                              void **this_prologue_cache)
870
{
871
  struct gdbarch *gdbarch = get_frame_arch (this_frame);
872
  CORE_ADDR pc = get_frame_pc (this_frame);
873
  char *name;
874
 
875
  /* NOTE: cagney/2004-04-30: Do not copy/clone this code.  Instead
876
     look at tramp-frame.h and other simplier per-architecture
877
     sigtramp unwinders.  */
878
 
879
  /* We shouldn't even bother to try if the OSABI didn't register a
880
     sigcontext_addr handler or pc_in_sigtramp hander.  */
881
  if (gdbarch_tdep (gdbarch)->sigcontext_addr == NULL)
882
    return 0;
883
  if (gdbarch_tdep (gdbarch)->pc_in_sigtramp == NULL)
884
    return 0;
885
 
886
  /* Otherwise we should be in a signal frame.  */
887
  find_pc_partial_function (pc, &name, NULL, NULL);
888
  if (gdbarch_tdep (gdbarch)->pc_in_sigtramp (gdbarch, pc, name))
889
    return 1;
890
 
891
  return 0;
892
}
893
 
894
static const struct frame_unwind alpha_sigtramp_frame_unwind = {
895
  SIGTRAMP_FRAME,
896
  alpha_sigtramp_frame_this_id,
897
  alpha_sigtramp_frame_prev_register,
898
  NULL,
899
  alpha_sigtramp_frame_sniffer
900
};
901
 
902
 
903
 
904
/* Heuristic_proc_start may hunt through the text section for a long
905
   time across a 2400 baud serial line.  Allows the user to limit this
906
   search.  */
907
static unsigned int heuristic_fence_post = 0;
908
 
909
/* Attempt to locate the start of the function containing PC.  We assume that
910
   the previous function ends with an about_to_return insn.  Not foolproof by
911
   any means, since gcc is happy to put the epilogue in the middle of a
912
   function.  But we're guessing anyway...  */
913
 
914
static CORE_ADDR
915
alpha_heuristic_proc_start (struct gdbarch *gdbarch, CORE_ADDR pc)
916
{
917
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
918
  CORE_ADDR last_non_nop = pc;
919
  CORE_ADDR fence = pc - heuristic_fence_post;
920
  CORE_ADDR orig_pc = pc;
921
  CORE_ADDR func;
922
  struct inferior *inf;
923
 
924
  if (pc == 0)
925
    return 0;
926
 
927
  /* First see if we can find the start of the function from minimal
928
     symbol information.  This can succeed with a binary that doesn't
929
     have debug info, but hasn't been stripped.  */
930
  func = get_pc_function_start (pc);
931
  if (func)
932
    return func;
933
 
934
  if (heuristic_fence_post == UINT_MAX
935
      || fence < tdep->vm_min_address)
936
    fence = tdep->vm_min_address;
937
 
938
  /* Search back for previous return; also stop at a 0, which might be
939
     seen for instance before the start of a code section.  Don't include
940
     nops, since this usually indicates padding between functions.  */
941
  for (pc -= ALPHA_INSN_SIZE; pc >= fence; pc -= ALPHA_INSN_SIZE)
942
    {
943
      unsigned int insn = alpha_read_insn (gdbarch, pc);
944
      switch (insn)
945
        {
946
        case 0:                  /* invalid insn */
947
        case 0x6bfa8001:        /* ret $31,($26),1 */
948
          return last_non_nop;
949
 
950
        case 0x2ffe0000:        /* unop: ldq_u $31,0($30) */
951
        case 0x47ff041f:        /* nop: bis $31,$31,$31 */
952
          break;
953
 
954
        default:
955
          last_non_nop = pc;
956
          break;
957
        }
958
    }
959
 
960
  inf = current_inferior ();
961
 
962
  /* It's not clear to me why we reach this point when stopping quietly,
963
     but with this test, at least we don't print out warnings for every
964
     child forked (eg, on decstation).  22apr93 rich@cygnus.com.  */
965
  if (inf->stop_soon == NO_STOP_QUIETLY)
966
    {
967
      static int blurb_printed = 0;
968
 
969
      if (fence == tdep->vm_min_address)
970
        warning (_("Hit beginning of text section without finding \
971
enclosing function for address %s"), paddress (gdbarch, orig_pc));
972
      else
973
        warning (_("Hit heuristic-fence-post without finding \
974
enclosing function for address %s"), paddress (gdbarch, orig_pc));
975
 
976
      if (!blurb_printed)
977
        {
978
          printf_filtered (_("\
979
This warning occurs if you are debugging a function without any symbols\n\
980
(for example, in a stripped executable).  In that case, you may wish to\n\
981
increase the size of the search with the `set heuristic-fence-post' command.\n\
982
\n\
983
Otherwise, you told GDB there was a function where there isn't one, or\n\
984
(more likely) you have encountered a bug in GDB.\n"));
985
          blurb_printed = 1;
986
        }
987
    }
988
 
989
  return 0;
990
}
991
 
992
/* Fallback alpha frame unwinder.  Uses instruction scanning and knows
993
   something about the traditional layout of alpha stack frames.  */
994
 
995
struct alpha_heuristic_unwind_cache
996
{
997
  CORE_ADDR vfp;
998
  CORE_ADDR start_pc;
999
  struct trad_frame_saved_reg *saved_regs;
1000
  int return_reg;
1001
};
1002
 
1003
static struct alpha_heuristic_unwind_cache *
1004
alpha_heuristic_frame_unwind_cache (struct frame_info *this_frame,
1005
                                    void **this_prologue_cache,
1006
                                    CORE_ADDR start_pc)
1007
{
1008
  struct gdbarch *gdbarch = get_frame_arch (this_frame);
1009
  struct alpha_heuristic_unwind_cache *info;
1010
  ULONGEST val;
1011
  CORE_ADDR limit_pc, cur_pc;
1012
  int frame_reg, frame_size, return_reg, reg;
1013
 
1014
  if (*this_prologue_cache)
1015
    return *this_prologue_cache;
1016
 
1017
  info = FRAME_OBSTACK_ZALLOC (struct alpha_heuristic_unwind_cache);
1018
  *this_prologue_cache = info;
1019
  info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
1020
 
1021
  limit_pc = get_frame_pc (this_frame);
1022
  if (start_pc == 0)
1023
    start_pc = alpha_heuristic_proc_start (gdbarch, limit_pc);
1024
  info->start_pc = start_pc;
1025
 
1026
  frame_reg = ALPHA_SP_REGNUM;
1027
  frame_size = 0;
1028
  return_reg = -1;
1029
 
1030
  /* If we've identified a likely place to start, do code scanning.  */
1031
  if (start_pc != 0)
1032
    {
1033
      /* Limit the forward search to 50 instructions.  */
1034
      if (start_pc + 200 < limit_pc)
1035
        limit_pc = start_pc + 200;
1036
 
1037
      for (cur_pc = start_pc; cur_pc < limit_pc; cur_pc += ALPHA_INSN_SIZE)
1038
        {
1039
          unsigned int word = alpha_read_insn (gdbarch, cur_pc);
1040
 
1041
          if ((word & 0xffff0000) == 0x23de0000)        /* lda $sp,n($sp) */
1042
            {
1043
              if (word & 0x8000)
1044
                {
1045
                  /* Consider only the first stack allocation instruction
1046
                     to contain the static size of the frame. */
1047
                  if (frame_size == 0)
1048
                    frame_size = (-word) & 0xffff;
1049
                }
1050
              else
1051
                {
1052
                  /* Exit loop if a positive stack adjustment is found, which
1053
                     usually means that the stack cleanup code in the function
1054
                     epilogue is reached.  */
1055
                  break;
1056
                }
1057
            }
1058
          else if ((word & 0xfc1f0000) == 0xb41e0000)   /* stq reg,n($sp) */
1059
            {
1060
              reg = (word & 0x03e00000) >> 21;
1061
 
1062
              /* Ignore this instruction if we have already encountered
1063
                 an instruction saving the same register earlier in the
1064
                 function code.  The current instruction does not tell
1065
                 us where the original value upon function entry is saved.
1066
                 All it says is that the function we are scanning reused
1067
                 that register for some computation of its own, and is now
1068
                 saving its result.  */
1069
              if (trad_frame_addr_p(info->saved_regs, reg))
1070
                continue;
1071
 
1072
              if (reg == 31)
1073
                continue;
1074
 
1075
              /* Do not compute the address where the register was saved yet,
1076
                 because we don't know yet if the offset will need to be
1077
                 relative to $sp or $fp (we can not compute the address
1078
                 relative to $sp if $sp is updated during the execution of
1079
                 the current subroutine, for instance when doing some alloca).
1080
                 So just store the offset for the moment, and compute the
1081
                 address later when we know whether this frame has a frame
1082
                 pointer or not.  */
1083
              /* Hack: temporarily add one, so that the offset is non-zero
1084
                 and we can tell which registers have save offsets below.  */
1085
              info->saved_regs[reg].addr = (word & 0xffff) + 1;
1086
 
1087
              /* Starting with OSF/1-3.2C, the system libraries are shipped
1088
                 without local symbols, but they still contain procedure
1089
                 descriptors without a symbol reference. GDB is currently
1090
                 unable to find these procedure descriptors and uses
1091
                 heuristic_proc_desc instead.
1092
                 As some low level compiler support routines (__div*, __add*)
1093
                 use a non-standard return address register, we have to
1094
                 add some heuristics to determine the return address register,
1095
                 or stepping over these routines will fail.
1096
                 Usually the return address register is the first register
1097
                 saved on the stack, but assembler optimization might
1098
                 rearrange the register saves.
1099
                 So we recognize only a few registers (t7, t9, ra) within
1100
                 the procedure prologue as valid return address registers.
1101
                 If we encounter a return instruction, we extract the
1102
                 the return address register from it.
1103
 
1104
                 FIXME: Rewriting GDB to access the procedure descriptors,
1105
                 e.g. via the minimal symbol table, might obviate this hack.  */
1106
              if (return_reg == -1
1107
                  && cur_pc < (start_pc + 80)
1108
                  && (reg == ALPHA_T7_REGNUM
1109
                      || reg == ALPHA_T9_REGNUM
1110
                      || reg == ALPHA_RA_REGNUM))
1111
                return_reg = reg;
1112
            }
1113
          else if ((word & 0xffe0ffff) == 0x6be08001)   /* ret zero,reg,1 */
1114
            return_reg = (word >> 16) & 0x1f;
1115
          else if (word == 0x47de040f)                  /* bis sp,sp,fp */
1116
            frame_reg = ALPHA_GCC_FP_REGNUM;
1117
          else if (word == 0x47fe040f)                  /* bis zero,sp,fp */
1118
            frame_reg = ALPHA_GCC_FP_REGNUM;
1119
        }
1120
 
1121
      /* If we haven't found a valid return address register yet, keep
1122
         searching in the procedure prologue.  */
1123
      if (return_reg == -1)
1124
        {
1125
          while (cur_pc < (limit_pc + 80) && cur_pc < (start_pc + 80))
1126
            {
1127
              unsigned int word = alpha_read_insn (gdbarch, cur_pc);
1128
 
1129
              if ((word & 0xfc1f0000) == 0xb41e0000)    /* stq reg,n($sp) */
1130
                {
1131
                  reg = (word & 0x03e00000) >> 21;
1132
                  if (reg == ALPHA_T7_REGNUM
1133
                      || reg == ALPHA_T9_REGNUM
1134
                      || reg == ALPHA_RA_REGNUM)
1135
                    {
1136
                      return_reg = reg;
1137
                      break;
1138
                    }
1139
                }
1140
              else if ((word & 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
1141
                {
1142
                  return_reg = (word >> 16) & 0x1f;
1143
                  break;
1144
                }
1145
 
1146
              cur_pc += ALPHA_INSN_SIZE;
1147
            }
1148
        }
1149
    }
1150
 
1151
  /* Failing that, do default to the customary RA.  */
1152
  if (return_reg == -1)
1153
    return_reg = ALPHA_RA_REGNUM;
1154
  info->return_reg = return_reg;
1155
 
1156
  val = get_frame_register_unsigned (this_frame, frame_reg);
1157
  info->vfp = val + frame_size;
1158
 
1159
  /* Convert offsets to absolute addresses.  See above about adding
1160
     one to the offsets to make all detected offsets non-zero.  */
1161
  for (reg = 0; reg < ALPHA_NUM_REGS; ++reg)
1162
    if (trad_frame_addr_p(info->saved_regs, reg))
1163
      info->saved_regs[reg].addr += val - 1;
1164
 
1165
  /* The stack pointer of the previous frame is computed by popping
1166
     the current stack frame.  */
1167
  if (!trad_frame_addr_p (info->saved_regs, ALPHA_SP_REGNUM))
1168
   trad_frame_set_value (info->saved_regs, ALPHA_SP_REGNUM, info->vfp);
1169
 
1170
  return info;
1171
}
1172
 
1173
/* Given a GDB frame, determine the address of the calling function's
1174
   frame.  This will be used to create a new GDB frame struct.  */
1175
 
1176
static void
1177
alpha_heuristic_frame_this_id (struct frame_info *this_frame,
1178
                               void **this_prologue_cache,
1179
                               struct frame_id *this_id)
1180
{
1181
  struct alpha_heuristic_unwind_cache *info
1182
    = alpha_heuristic_frame_unwind_cache (this_frame, this_prologue_cache, 0);
1183
 
1184
  *this_id = frame_id_build (info->vfp, info->start_pc);
1185
}
1186
 
1187
/* Retrieve the value of REGNUM in FRAME.  Don't give up!  */
1188
 
1189
static struct value *
1190
alpha_heuristic_frame_prev_register (struct frame_info *this_frame,
1191
                                     void **this_prologue_cache, int regnum)
1192
{
1193
  struct alpha_heuristic_unwind_cache *info
1194
    = alpha_heuristic_frame_unwind_cache (this_frame, this_prologue_cache, 0);
1195
 
1196
  /* The PC of the previous frame is stored in the link register of
1197
     the current frame.  Frob regnum so that we pull the value from
1198
     the correct place.  */
1199
  if (regnum == ALPHA_PC_REGNUM)
1200
    regnum = info->return_reg;
1201
 
1202
  return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
1203
}
1204
 
1205
static const struct frame_unwind alpha_heuristic_frame_unwind = {
1206
  NORMAL_FRAME,
1207
  alpha_heuristic_frame_this_id,
1208
  alpha_heuristic_frame_prev_register,
1209
  NULL,
1210
  default_frame_sniffer
1211
};
1212
 
1213
static CORE_ADDR
1214
alpha_heuristic_frame_base_address (struct frame_info *this_frame,
1215
                                    void **this_prologue_cache)
1216
{
1217
  struct alpha_heuristic_unwind_cache *info
1218
    = alpha_heuristic_frame_unwind_cache (this_frame, this_prologue_cache, 0);
1219
 
1220
  return info->vfp;
1221
}
1222
 
1223
static const struct frame_base alpha_heuristic_frame_base = {
1224
  &alpha_heuristic_frame_unwind,
1225
  alpha_heuristic_frame_base_address,
1226
  alpha_heuristic_frame_base_address,
1227
  alpha_heuristic_frame_base_address
1228
};
1229
 
1230
/* Just like reinit_frame_cache, but with the right arguments to be
1231
   callable as an sfunc.  Used by the "set heuristic-fence-post" command.  */
1232
 
1233
static void
1234
reinit_frame_cache_sfunc (char *args, int from_tty, struct cmd_list_element *c)
1235
{
1236
  reinit_frame_cache ();
1237
}
1238
 
1239
 
1240
/* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
1241
   dummy frame.  The frame ID's base needs to match the TOS value
1242
   saved by save_dummy_frame_tos(), and the PC match the dummy frame's
1243
   breakpoint.  */
1244
 
1245
static struct frame_id
1246
alpha_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
1247
{
1248
  ULONGEST base;
1249
  base = get_frame_register_unsigned (this_frame, ALPHA_SP_REGNUM);
1250
  return frame_id_build (base, get_frame_pc (this_frame));
1251
}
1252
 
1253
static CORE_ADDR
1254
alpha_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
1255
{
1256
  ULONGEST pc;
1257
  pc = frame_unwind_register_unsigned (next_frame, ALPHA_PC_REGNUM);
1258
  return pc;
1259
}
1260
 
1261
 
1262
/* Helper routines for alpha*-nat.c files to move register sets to and
1263
   from core files.  The UNIQUE pointer is allowed to be NULL, as most
1264
   targets don't supply this value in their core files.  */
1265
 
1266
void
1267
alpha_supply_int_regs (struct regcache *regcache, int regno,
1268
                       const void *r0_r30, const void *pc, const void *unique)
1269
{
1270
  const gdb_byte *regs = r0_r30;
1271
  int i;
1272
 
1273
  for (i = 0; i < 31; ++i)
1274
    if (regno == i || regno == -1)
1275
      regcache_raw_supply (regcache, i, regs + i * 8);
1276
 
1277
  if (regno == ALPHA_ZERO_REGNUM || regno == -1)
1278
    regcache_raw_supply (regcache, ALPHA_ZERO_REGNUM, NULL);
1279
 
1280
  if (regno == ALPHA_PC_REGNUM || regno == -1)
1281
    regcache_raw_supply (regcache, ALPHA_PC_REGNUM, pc);
1282
 
1283
  if (regno == ALPHA_UNIQUE_REGNUM || regno == -1)
1284
    regcache_raw_supply (regcache, ALPHA_UNIQUE_REGNUM, unique);
1285
}
1286
 
1287
void
1288
alpha_fill_int_regs (const struct regcache *regcache,
1289
                     int regno, void *r0_r30, void *pc, void *unique)
1290
{
1291
  gdb_byte *regs = r0_r30;
1292
  int i;
1293
 
1294
  for (i = 0; i < 31; ++i)
1295
    if (regno == i || regno == -1)
1296
      regcache_raw_collect (regcache, i, regs + i * 8);
1297
 
1298
  if (regno == ALPHA_PC_REGNUM || regno == -1)
1299
    regcache_raw_collect (regcache, ALPHA_PC_REGNUM, pc);
1300
 
1301
  if (unique && (regno == ALPHA_UNIQUE_REGNUM || regno == -1))
1302
    regcache_raw_collect (regcache, ALPHA_UNIQUE_REGNUM, unique);
1303
}
1304
 
1305
void
1306
alpha_supply_fp_regs (struct regcache *regcache, int regno,
1307
                      const void *f0_f30, const void *fpcr)
1308
{
1309
  const gdb_byte *regs = f0_f30;
1310
  int i;
1311
 
1312
  for (i = ALPHA_FP0_REGNUM; i < ALPHA_FP0_REGNUM + 31; ++i)
1313
    if (regno == i || regno == -1)
1314
      regcache_raw_supply (regcache, i,
1315
                           regs + (i - ALPHA_FP0_REGNUM) * 8);
1316
 
1317
  if (regno == ALPHA_FPCR_REGNUM || regno == -1)
1318
    regcache_raw_supply (regcache, ALPHA_FPCR_REGNUM, fpcr);
1319
}
1320
 
1321
void
1322
alpha_fill_fp_regs (const struct regcache *regcache,
1323
                    int regno, void *f0_f30, void *fpcr)
1324
{
1325
  gdb_byte *regs = f0_f30;
1326
  int i;
1327
 
1328
  for (i = ALPHA_FP0_REGNUM; i < ALPHA_FP0_REGNUM + 31; ++i)
1329
    if (regno == i || regno == -1)
1330
      regcache_raw_collect (regcache, i,
1331
                            regs + (i - ALPHA_FP0_REGNUM) * 8);
1332
 
1333
  if (regno == ALPHA_FPCR_REGNUM || regno == -1)
1334
    regcache_raw_collect (regcache, ALPHA_FPCR_REGNUM, fpcr);
1335
}
1336
 
1337
 
1338
 
1339
/* Return nonzero if the G_floating register value in REG is equal to
1340
   zero for FP control instructions.  */
1341
 
1342
static int
1343
fp_register_zero_p (LONGEST reg)
1344
{
1345
  /* Check that all bits except the sign bit are zero.  */
1346
  const LONGEST zero_mask = ((LONGEST) 1 << 63) ^ -1;
1347
 
1348
  return ((reg & zero_mask) == 0);
1349
}
1350
 
1351
/* Return the value of the sign bit for the G_floating register
1352
   value held in REG.  */
1353
 
1354
static int
1355
fp_register_sign_bit (LONGEST reg)
1356
{
1357
  const LONGEST sign_mask = (LONGEST) 1 << 63;
1358
 
1359
  return ((reg & sign_mask) != 0);
1360
}
1361
 
1362
/* alpha_software_single_step() is called just before we want to resume
1363
   the inferior, if we want to single-step it but there is no hardware
1364
   or kernel single-step support (NetBSD on Alpha, for example).  We find
1365
   the target of the coming instruction and breakpoint it.  */
1366
 
1367
static CORE_ADDR
1368
alpha_next_pc (struct frame_info *frame, CORE_ADDR pc)
1369
{
1370
  struct gdbarch *gdbarch = get_frame_arch (frame);
1371
  unsigned int insn;
1372
  unsigned int op;
1373
  int regno;
1374
  int offset;
1375
  LONGEST rav;
1376
 
1377
  insn = alpha_read_insn (gdbarch, pc);
1378
 
1379
  /* Opcode is top 6 bits. */
1380
  op = (insn >> 26) & 0x3f;
1381
 
1382
  if (op == 0x1a)
1383
    {
1384
      /* Jump format: target PC is:
1385
         RB & ~3  */
1386
      return (get_frame_register_unsigned (frame, (insn >> 16) & 0x1f) & ~3);
1387
    }
1388
 
1389
  if ((op & 0x30) == 0x30)
1390
    {
1391
      /* Branch format: target PC is:
1392
         (new PC) + (4 * sext(displacement))  */
1393
      if (op == 0x30            /* BR */
1394
          || op == 0x34)        /* BSR */
1395
        {
1396
 branch_taken:
1397
          offset = (insn & 0x001fffff);
1398
          if (offset & 0x00100000)
1399
            offset  |= 0xffe00000;
1400
          offset *= ALPHA_INSN_SIZE;
1401
          return (pc + ALPHA_INSN_SIZE + offset);
1402
        }
1403
 
1404
      /* Need to determine if branch is taken; read RA.  */
1405
      regno = (insn >> 21) & 0x1f;
1406
      switch (op)
1407
        {
1408
          case 0x31:              /* FBEQ */
1409
          case 0x36:              /* FBGE */
1410
          case 0x37:              /* FBGT */
1411
          case 0x33:              /* FBLE */
1412
          case 0x32:              /* FBLT */
1413
          case 0x35:              /* FBNE */
1414
            regno += gdbarch_fp0_regnum (gdbarch);
1415
        }
1416
 
1417
      rav = get_frame_register_signed (frame, regno);
1418
 
1419
      switch (op)
1420
        {
1421
        case 0x38:              /* BLBC */
1422
          if ((rav & 1) == 0)
1423
            goto branch_taken;
1424
          break;
1425
        case 0x3c:              /* BLBS */
1426
          if (rav & 1)
1427
            goto branch_taken;
1428
          break;
1429
        case 0x39:              /* BEQ */
1430
          if (rav == 0)
1431
            goto branch_taken;
1432
          break;
1433
        case 0x3d:              /* BNE */
1434
          if (rav != 0)
1435
            goto branch_taken;
1436
          break;
1437
        case 0x3a:              /* BLT */
1438
          if (rav < 0)
1439
            goto branch_taken;
1440
          break;
1441
        case 0x3b:              /* BLE */
1442
          if (rav <= 0)
1443
            goto branch_taken;
1444
          break;
1445
        case 0x3f:              /* BGT */
1446
          if (rav > 0)
1447
            goto branch_taken;
1448
          break;
1449
        case 0x3e:              /* BGE */
1450
          if (rav >= 0)
1451
            goto branch_taken;
1452
          break;
1453
 
1454
        /* Floating point branches.  */
1455
 
1456
        case 0x31:              /* FBEQ */
1457
          if (fp_register_zero_p (rav))
1458
            goto branch_taken;
1459
          break;
1460
        case 0x36:              /* FBGE */
1461
          if (fp_register_sign_bit (rav) == 0 || fp_register_zero_p (rav))
1462
            goto branch_taken;
1463
          break;
1464
        case 0x37:              /* FBGT */
1465
          if (fp_register_sign_bit (rav) == 0 && ! fp_register_zero_p (rav))
1466
            goto branch_taken;
1467
          break;
1468
        case 0x33:              /* FBLE */
1469
          if (fp_register_sign_bit (rav) == 1 || fp_register_zero_p (rav))
1470
            goto branch_taken;
1471
          break;
1472
        case 0x32:              /* FBLT */
1473
          if (fp_register_sign_bit (rav) == 1 && ! fp_register_zero_p (rav))
1474
            goto branch_taken;
1475
          break;
1476
        case 0x35:              /* FBNE */
1477
          if (! fp_register_zero_p (rav))
1478
            goto branch_taken;
1479
          break;
1480
        }
1481
    }
1482
 
1483
  /* Not a branch or branch not taken; target PC is:
1484
     pc + 4  */
1485
  return (pc + ALPHA_INSN_SIZE);
1486
}
1487
 
1488
int
1489
alpha_software_single_step (struct frame_info *frame)
1490
{
1491
  struct gdbarch *gdbarch = get_frame_arch (frame);
1492
  struct address_space *aspace = get_frame_address_space (frame);
1493
  CORE_ADDR pc, next_pc;
1494
 
1495
  pc = get_frame_pc (frame);
1496
  next_pc = alpha_next_pc (frame, pc);
1497
 
1498
  insert_single_step_breakpoint (gdbarch, aspace, next_pc);
1499
  return 1;
1500
}
1501
 
1502
 
1503
/* Initialize the current architecture based on INFO.  If possible, re-use an
1504
   architecture from ARCHES, which is a list of architectures already created
1505
   during this debugging session.
1506
 
1507
   Called e.g. at program startup, when reading a core file, and when reading
1508
   a binary file.  */
1509
 
1510
static struct gdbarch *
1511
alpha_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1512
{
1513
  struct gdbarch_tdep *tdep;
1514
  struct gdbarch *gdbarch;
1515
 
1516
  /* Try to determine the ABI of the object we are loading.  */
1517
  if (info.abfd != NULL && info.osabi == GDB_OSABI_UNKNOWN)
1518
    {
1519
      /* If it's an ECOFF file, assume it's OSF/1.  */
1520
      if (bfd_get_flavour (info.abfd) == bfd_target_ecoff_flavour)
1521
        info.osabi = GDB_OSABI_OSF1;
1522
    }
1523
 
1524
  /* Find a candidate among extant architectures.  */
1525
  arches = gdbarch_list_lookup_by_info (arches, &info);
1526
  if (arches != NULL)
1527
    return arches->gdbarch;
1528
 
1529
  tdep = xmalloc (sizeof (struct gdbarch_tdep));
1530
  gdbarch = gdbarch_alloc (&info, tdep);
1531
 
1532
  /* Lowest text address.  This is used by heuristic_proc_start()
1533
     to decide when to stop looking.  */
1534
  tdep->vm_min_address = (CORE_ADDR) 0x120000000LL;
1535
 
1536
  tdep->dynamic_sigtramp_offset = NULL;
1537
  tdep->sigcontext_addr = NULL;
1538
  tdep->sc_pc_offset = 2 * 8;
1539
  tdep->sc_regs_offset = 4 * 8;
1540
  tdep->sc_fpregs_offset = tdep->sc_regs_offset + 32 * 8 + 8;
1541
 
1542
  tdep->jb_pc = -1;     /* longjmp support not enabled by default  */
1543
 
1544
  tdep->return_in_memory = alpha_return_in_memory_always;
1545
 
1546
  /* Type sizes */
1547
  set_gdbarch_short_bit (gdbarch, 16);
1548
  set_gdbarch_int_bit (gdbarch, 32);
1549
  set_gdbarch_long_bit (gdbarch, 64);
1550
  set_gdbarch_long_long_bit (gdbarch, 64);
1551
  set_gdbarch_float_bit (gdbarch, 32);
1552
  set_gdbarch_double_bit (gdbarch, 64);
1553
  set_gdbarch_long_double_bit (gdbarch, 64);
1554
  set_gdbarch_ptr_bit (gdbarch, 64);
1555
 
1556
  /* Register info */
1557
  set_gdbarch_num_regs (gdbarch, ALPHA_NUM_REGS);
1558
  set_gdbarch_sp_regnum (gdbarch, ALPHA_SP_REGNUM);
1559
  set_gdbarch_pc_regnum (gdbarch, ALPHA_PC_REGNUM);
1560
  set_gdbarch_fp0_regnum (gdbarch, ALPHA_FP0_REGNUM);
1561
 
1562
  set_gdbarch_register_name (gdbarch, alpha_register_name);
1563
  set_gdbarch_register_type (gdbarch, alpha_register_type);
1564
 
1565
  set_gdbarch_cannot_fetch_register (gdbarch, alpha_cannot_fetch_register);
1566
  set_gdbarch_cannot_store_register (gdbarch, alpha_cannot_store_register);
1567
 
1568
  set_gdbarch_convert_register_p (gdbarch, alpha_convert_register_p);
1569
  set_gdbarch_register_to_value (gdbarch, alpha_register_to_value);
1570
  set_gdbarch_value_to_register (gdbarch, alpha_value_to_register);
1571
 
1572
  set_gdbarch_register_reggroup_p (gdbarch, alpha_register_reggroup_p);
1573
 
1574
  /* Prologue heuristics.  */
1575
  set_gdbarch_skip_prologue (gdbarch, alpha_skip_prologue);
1576
 
1577
  /* Disassembler.  */
1578
  set_gdbarch_print_insn (gdbarch, print_insn_alpha);
1579
 
1580
  /* Call info.  */
1581
 
1582
  set_gdbarch_return_value (gdbarch, alpha_return_value);
1583
 
1584
  /* Settings for calling functions in the inferior.  */
1585
  set_gdbarch_push_dummy_call (gdbarch, alpha_push_dummy_call);
1586
 
1587
  /* Methods for saving / extracting a dummy frame's ID.  */
1588
  set_gdbarch_dummy_id (gdbarch, alpha_dummy_id);
1589
 
1590
  /* Return the unwound PC value.  */
1591
  set_gdbarch_unwind_pc (gdbarch, alpha_unwind_pc);
1592
 
1593
  set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1594
  set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
1595
 
1596
  set_gdbarch_breakpoint_from_pc (gdbarch, alpha_breakpoint_from_pc);
1597
  set_gdbarch_decr_pc_after_break (gdbarch, ALPHA_INSN_SIZE);
1598
  set_gdbarch_cannot_step_breakpoint (gdbarch, 1);
1599
 
1600
  /* Hook in ABI-specific overrides, if they have been registered.  */
1601
  gdbarch_init_osabi (info, gdbarch);
1602
 
1603
  /* Now that we have tuned the configuration, set a few final things
1604
     based on what the OS ABI has told us.  */
1605
 
1606
  if (tdep->jb_pc >= 0)
1607
    set_gdbarch_get_longjmp_target (gdbarch, alpha_get_longjmp_target);
1608
 
1609
  frame_unwind_append_unwinder (gdbarch, &alpha_sigtramp_frame_unwind);
1610
  frame_unwind_append_unwinder (gdbarch, &alpha_heuristic_frame_unwind);
1611
 
1612
  frame_base_set_default (gdbarch, &alpha_heuristic_frame_base);
1613
 
1614
  return gdbarch;
1615
}
1616
 
1617
void
1618
alpha_dwarf2_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1619
{
1620
  dwarf2_append_unwinders (gdbarch);
1621
  frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer);
1622
}
1623
 
1624
extern initialize_file_ftype _initialize_alpha_tdep; /* -Wmissing-prototypes */
1625
 
1626
void
1627
_initialize_alpha_tdep (void)
1628
{
1629
  struct cmd_list_element *c;
1630
 
1631
  gdbarch_register (bfd_arch_alpha, alpha_gdbarch_init, NULL);
1632
 
1633
  /* Let the user set the fence post for heuristic_proc_start.  */
1634
 
1635
  /* We really would like to have both "0" and "unlimited" work, but
1636
     command.c doesn't deal with that.  So make it a var_zinteger
1637
     because the user can always use "999999" or some such for unlimited.  */
1638
  /* We need to throw away the frame cache when we set this, since it
1639
     might change our ability to get backtraces.  */
1640
  add_setshow_zinteger_cmd ("heuristic-fence-post", class_support,
1641
                            &heuristic_fence_post, _("\
1642
Set the distance searched for the start of a function."), _("\
1643
Show the distance searched for the start of a function."), _("\
1644
If you are debugging a stripped executable, GDB needs to search through the\n\
1645
program for the start of a function.  This command sets the distance of the\n\
1646
search.  The only need to set it is when debugging a stripped executable."),
1647
                            reinit_frame_cache_sfunc,
1648
                            NULL, /* FIXME: i18n: The distance searched for the start of a function is \"%d\".  */
1649
                            &setlist, &showlist);
1650
}

powered by: WebSVN 2.1.0

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