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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [hppa-tdep.c] - Blame information for rev 233

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

Line No. Rev Author Line
1 24 jeremybenn
/* Target-dependent code for the HP PA-RISC architecture.
2
 
3
   Copyright (C) 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
4
   1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008
5
   Free Software Foundation, Inc.
6
 
7
   Contributed by the Center for Software Science at the
8
   University of Utah (pa-gdb-bugs@cs.utah.edu).
9
 
10
   This file is part of GDB.
11
 
12
   This program is free software; you can redistribute it and/or modify
13
   it under the terms of the GNU General Public License as published by
14
   the Free Software Foundation; either version 3 of the License, or
15
   (at your option) any later version.
16
 
17
   This program is distributed in the hope that it will be useful,
18
   but WITHOUT ANY WARRANTY; without even the implied warranty of
19
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20
   GNU General Public License for more details.
21
 
22
   You should have received a copy of the GNU General Public License
23
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
24
 
25
#include "defs.h"
26
#include "bfd.h"
27
#include "inferior.h"
28
#include "regcache.h"
29
#include "completer.h"
30
#include "osabi.h"
31
#include "gdb_assert.h"
32
#include "gdb_stdint.h"
33
#include "arch-utils.h"
34
/* For argument passing to the inferior */
35
#include "symtab.h"
36
#include "dis-asm.h"
37
#include "trad-frame.h"
38
#include "frame-unwind.h"
39
#include "frame-base.h"
40
 
41
#include "gdbcore.h"
42
#include "gdbcmd.h"
43
#include "gdbtypes.h"
44
#include "objfiles.h"
45
#include "hppa-tdep.h"
46
 
47
static int hppa_debug = 0;
48
 
49
/* Some local constants.  */
50
static const int hppa32_num_regs = 128;
51
static const int hppa64_num_regs = 96;
52
 
53
/* hppa-specific object data -- unwind and solib info.
54
   TODO/maybe: think about splitting this into two parts; the unwind data is
55
   common to all hppa targets, but is only used in this file; we can register
56
   that separately and make this static. The solib data is probably hpux-
57
   specific, so we can create a separate extern objfile_data that is registered
58
   by hppa-hpux-tdep.c and shared with pa64solib.c and somsolib.c.  */
59
const struct objfile_data *hppa_objfile_priv_data = NULL;
60
 
61
/* Get at various relevent fields of an instruction word. */
62
#define MASK_5 0x1f
63
#define MASK_11 0x7ff
64
#define MASK_14 0x3fff
65
#define MASK_21 0x1fffff
66
 
67
/* Sizes (in bytes) of the native unwind entries.  */
68
#define UNWIND_ENTRY_SIZE 16
69
#define STUB_UNWIND_ENTRY_SIZE 8
70
 
71
/* Routines to extract various sized constants out of hppa
72
   instructions. */
73
 
74
/* This assumes that no garbage lies outside of the lower bits of
75
   value. */
76
 
77
int
78
hppa_sign_extend (unsigned val, unsigned bits)
79
{
80
  return (int) (val >> (bits - 1) ? (-1 << bits) | val : val);
81
}
82
 
83
/* For many immediate values the sign bit is the low bit! */
84
 
85
int
86
hppa_low_hppa_sign_extend (unsigned val, unsigned bits)
87
{
88
  return (int) ((val & 0x1 ? (-1 << (bits - 1)) : 0) | val >> 1);
89
}
90
 
91
/* Extract the bits at positions between FROM and TO, using HP's numbering
92
   (MSB = 0). */
93
 
94
int
95
hppa_get_field (unsigned word, int from, int to)
96
{
97
  return ((word) >> (31 - (to)) & ((1 << ((to) - (from) + 1)) - 1));
98
}
99
 
100
/* extract the immediate field from a ld{bhw}s instruction */
101
 
102
int
103
hppa_extract_5_load (unsigned word)
104
{
105
  return hppa_low_hppa_sign_extend (word >> 16 & MASK_5, 5);
106
}
107
 
108
/* extract the immediate field from a break instruction */
109
 
110
unsigned
111
hppa_extract_5r_store (unsigned word)
112
{
113
  return (word & MASK_5);
114
}
115
 
116
/* extract the immediate field from a {sr}sm instruction */
117
 
118
unsigned
119
hppa_extract_5R_store (unsigned word)
120
{
121
  return (word >> 16 & MASK_5);
122
}
123
 
124
/* extract a 14 bit immediate field */
125
 
126
int
127
hppa_extract_14 (unsigned word)
128
{
129
  return hppa_low_hppa_sign_extend (word & MASK_14, 14);
130
}
131
 
132
/* extract a 21 bit constant */
133
 
134
int
135
hppa_extract_21 (unsigned word)
136
{
137
  int val;
138
 
139
  word &= MASK_21;
140
  word <<= 11;
141
  val = hppa_get_field (word, 20, 20);
142
  val <<= 11;
143
  val |= hppa_get_field (word, 9, 19);
144
  val <<= 2;
145
  val |= hppa_get_field (word, 5, 6);
146
  val <<= 5;
147
  val |= hppa_get_field (word, 0, 4);
148
  val <<= 2;
149
  val |= hppa_get_field (word, 7, 8);
150
  return hppa_sign_extend (val, 21) << 11;
151
}
152
 
153
/* extract a 17 bit constant from branch instructions, returning the
154
   19 bit signed value. */
155
 
156
int
157
hppa_extract_17 (unsigned word)
158
{
159
  return hppa_sign_extend (hppa_get_field (word, 19, 28) |
160
                      hppa_get_field (word, 29, 29) << 10 |
161
                      hppa_get_field (word, 11, 15) << 11 |
162
                      (word & 0x1) << 16, 17) << 2;
163
}
164
 
165
CORE_ADDR
166
hppa_symbol_address(const char *sym)
167
{
168
  struct minimal_symbol *minsym;
169
 
170
  minsym = lookup_minimal_symbol (sym, NULL, NULL);
171
  if (minsym)
172
    return SYMBOL_VALUE_ADDRESS (minsym);
173
  else
174
    return (CORE_ADDR)-1;
175
}
176
 
177
struct hppa_objfile_private *
178
hppa_init_objfile_priv_data (struct objfile *objfile)
179
{
180
  struct hppa_objfile_private *priv;
181
 
182
  priv = (struct hppa_objfile_private *)
183
         obstack_alloc (&objfile->objfile_obstack,
184
                        sizeof (struct hppa_objfile_private));
185
  set_objfile_data (objfile, hppa_objfile_priv_data, priv);
186
  memset (priv, 0, sizeof (*priv));
187
 
188
  return priv;
189
}
190
 
191
 
192
/* Compare the start address for two unwind entries returning 1 if
193
   the first address is larger than the second, -1 if the second is
194
   larger than the first, and zero if they are equal.  */
195
 
196
static int
197
compare_unwind_entries (const void *arg1, const void *arg2)
198
{
199
  const struct unwind_table_entry *a = arg1;
200
  const struct unwind_table_entry *b = arg2;
201
 
202
  if (a->region_start > b->region_start)
203
    return 1;
204
  else if (a->region_start < b->region_start)
205
    return -1;
206
  else
207
    return 0;
208
}
209
 
210
static void
211
record_text_segment_lowaddr (bfd *abfd, asection *section, void *data)
212
{
213
  if ((section->flags & (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
214
       == (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
215
    {
216
      bfd_vma value = section->vma - section->filepos;
217
      CORE_ADDR *low_text_segment_address = (CORE_ADDR *)data;
218
 
219
      if (value < *low_text_segment_address)
220
          *low_text_segment_address = value;
221
    }
222
}
223
 
224
static void
225
internalize_unwinds (struct objfile *objfile, struct unwind_table_entry *table,
226
                     asection *section, unsigned int entries, unsigned int size,
227
                     CORE_ADDR text_offset)
228
{
229
  /* We will read the unwind entries into temporary memory, then
230
     fill in the actual unwind table.  */
231
 
232
  if (size > 0)
233
    {
234
      unsigned long tmp;
235
      unsigned i;
236
      char *buf = alloca (size);
237
      CORE_ADDR low_text_segment_address;
238
 
239
      /* For ELF targets, then unwinds are supposed to
240
         be segment relative offsets instead of absolute addresses.
241
 
242
         Note that when loading a shared library (text_offset != 0) the
243
         unwinds are already relative to the text_offset that will be
244
         passed in.  */
245
      if (gdbarch_tdep (current_gdbarch)->is_elf && text_offset == 0)
246
        {
247
          low_text_segment_address = -1;
248
 
249
          bfd_map_over_sections (objfile->obfd,
250
                                 record_text_segment_lowaddr,
251
                                 &low_text_segment_address);
252
 
253
          text_offset = low_text_segment_address;
254
        }
255
      else if (gdbarch_tdep (current_gdbarch)->solib_get_text_base)
256
        {
257
          text_offset = gdbarch_tdep (current_gdbarch)->solib_get_text_base (objfile);
258
        }
259
 
260
      bfd_get_section_contents (objfile->obfd, section, buf, 0, size);
261
 
262
      /* Now internalize the information being careful to handle host/target
263
         endian issues.  */
264
      for (i = 0; i < entries; i++)
265
        {
266
          table[i].region_start = bfd_get_32 (objfile->obfd,
267
                                              (bfd_byte *) buf);
268
          table[i].region_start += text_offset;
269
          buf += 4;
270
          table[i].region_end = bfd_get_32 (objfile->obfd, (bfd_byte *) buf);
271
          table[i].region_end += text_offset;
272
          buf += 4;
273
          tmp = bfd_get_32 (objfile->obfd, (bfd_byte *) buf);
274
          buf += 4;
275
          table[i].Cannot_unwind = (tmp >> 31) & 0x1;
276
          table[i].Millicode = (tmp >> 30) & 0x1;
277
          table[i].Millicode_save_sr0 = (tmp >> 29) & 0x1;
278
          table[i].Region_description = (tmp >> 27) & 0x3;
279
          table[i].reserved = (tmp >> 26) & 0x1;
280
          table[i].Entry_SR = (tmp >> 25) & 0x1;
281
          table[i].Entry_FR = (tmp >> 21) & 0xf;
282
          table[i].Entry_GR = (tmp >> 16) & 0x1f;
283
          table[i].Args_stored = (tmp >> 15) & 0x1;
284
          table[i].Variable_Frame = (tmp >> 14) & 0x1;
285
          table[i].Separate_Package_Body = (tmp >> 13) & 0x1;
286
          table[i].Frame_Extension_Millicode = (tmp >> 12) & 0x1;
287
          table[i].Stack_Overflow_Check = (tmp >> 11) & 0x1;
288
          table[i].Two_Instruction_SP_Increment = (tmp >> 10) & 0x1;
289
          table[i].sr4export = (tmp >> 9) & 0x1;
290
          table[i].cxx_info = (tmp >> 8) & 0x1;
291
          table[i].cxx_try_catch = (tmp >> 7) & 0x1;
292
          table[i].sched_entry_seq = (tmp >> 6) & 0x1;
293
          table[i].reserved1 = (tmp >> 5) & 0x1;
294
          table[i].Save_SP = (tmp >> 4) & 0x1;
295
          table[i].Save_RP = (tmp >> 3) & 0x1;
296
          table[i].Save_MRP_in_frame = (tmp >> 2) & 0x1;
297
          table[i].save_r19 = (tmp >> 1) & 0x1;
298
          table[i].Cleanup_defined = tmp & 0x1;
299
          tmp = bfd_get_32 (objfile->obfd, (bfd_byte *) buf);
300
          buf += 4;
301
          table[i].MPE_XL_interrupt_marker = (tmp >> 31) & 0x1;
302
          table[i].HP_UX_interrupt_marker = (tmp >> 30) & 0x1;
303
          table[i].Large_frame = (tmp >> 29) & 0x1;
304
          table[i].alloca_frame = (tmp >> 28) & 0x1;
305
          table[i].reserved2 = (tmp >> 27) & 0x1;
306
          table[i].Total_frame_size = tmp & 0x7ffffff;
307
 
308
          /* Stub unwinds are handled elsewhere. */
309
          table[i].stub_unwind.stub_type = 0;
310
          table[i].stub_unwind.padding = 0;
311
        }
312
    }
313
}
314
 
315
/* Read in the backtrace information stored in the `$UNWIND_START$' section of
316
   the object file.  This info is used mainly by find_unwind_entry() to find
317
   out the stack frame size and frame pointer used by procedures.  We put
318
   everything on the psymbol obstack in the objfile so that it automatically
319
   gets freed when the objfile is destroyed.  */
320
 
321
static void
322
read_unwind_info (struct objfile *objfile)
323
{
324
  asection *unwind_sec, *stub_unwind_sec;
325
  unsigned unwind_size, stub_unwind_size, total_size;
326
  unsigned index, unwind_entries;
327
  unsigned stub_entries, total_entries;
328
  CORE_ADDR text_offset;
329
  struct hppa_unwind_info *ui;
330
  struct hppa_objfile_private *obj_private;
331
 
332
  text_offset = ANOFFSET (objfile->section_offsets, 0);
333
  ui = (struct hppa_unwind_info *) obstack_alloc (&objfile->objfile_obstack,
334
                                           sizeof (struct hppa_unwind_info));
335
 
336
  ui->table = NULL;
337
  ui->cache = NULL;
338
  ui->last = -1;
339
 
340
  /* For reasons unknown the HP PA64 tools generate multiple unwinder
341
     sections in a single executable.  So we just iterate over every
342
     section in the BFD looking for unwinder sections intead of trying
343
     to do a lookup with bfd_get_section_by_name.
344
 
345
     First determine the total size of the unwind tables so that we
346
     can allocate memory in a nice big hunk.  */
347
  total_entries = 0;
348
  for (unwind_sec = objfile->obfd->sections;
349
       unwind_sec;
350
       unwind_sec = unwind_sec->next)
351
    {
352
      if (strcmp (unwind_sec->name, "$UNWIND_START$") == 0
353
          || strcmp (unwind_sec->name, ".PARISC.unwind") == 0)
354
        {
355
          unwind_size = bfd_section_size (objfile->obfd, unwind_sec);
356
          unwind_entries = unwind_size / UNWIND_ENTRY_SIZE;
357
 
358
          total_entries += unwind_entries;
359
        }
360
    }
361
 
362
  /* Now compute the size of the stub unwinds.  Note the ELF tools do not
363
     use stub unwinds at the current time.  */
364
  stub_unwind_sec = bfd_get_section_by_name (objfile->obfd, "$UNWIND_END$");
365
 
366
  if (stub_unwind_sec)
367
    {
368
      stub_unwind_size = bfd_section_size (objfile->obfd, stub_unwind_sec);
369
      stub_entries = stub_unwind_size / STUB_UNWIND_ENTRY_SIZE;
370
    }
371
  else
372
    {
373
      stub_unwind_size = 0;
374
      stub_entries = 0;
375
    }
376
 
377
  /* Compute total number of unwind entries and their total size.  */
378
  total_entries += stub_entries;
379
  total_size = total_entries * sizeof (struct unwind_table_entry);
380
 
381
  /* Allocate memory for the unwind table.  */
382
  ui->table = (struct unwind_table_entry *)
383
    obstack_alloc (&objfile->objfile_obstack, total_size);
384
  ui->last = total_entries - 1;
385
 
386
  /* Now read in each unwind section and internalize the standard unwind
387
     entries.  */
388
  index = 0;
389
  for (unwind_sec = objfile->obfd->sections;
390
       unwind_sec;
391
       unwind_sec = unwind_sec->next)
392
    {
393
      if (strcmp (unwind_sec->name, "$UNWIND_START$") == 0
394
          || strcmp (unwind_sec->name, ".PARISC.unwind") == 0)
395
        {
396
          unwind_size = bfd_section_size (objfile->obfd, unwind_sec);
397
          unwind_entries = unwind_size / UNWIND_ENTRY_SIZE;
398
 
399
          internalize_unwinds (objfile, &ui->table[index], unwind_sec,
400
                               unwind_entries, unwind_size, text_offset);
401
          index += unwind_entries;
402
        }
403
    }
404
 
405
  /* Now read in and internalize the stub unwind entries.  */
406
  if (stub_unwind_size > 0)
407
    {
408
      unsigned int i;
409
      char *buf = alloca (stub_unwind_size);
410
 
411
      /* Read in the stub unwind entries.  */
412
      bfd_get_section_contents (objfile->obfd, stub_unwind_sec, buf,
413
                                0, stub_unwind_size);
414
 
415
      /* Now convert them into regular unwind entries.  */
416
      for (i = 0; i < stub_entries; i++, index++)
417
        {
418
          /* Clear out the next unwind entry.  */
419
          memset (&ui->table[index], 0, sizeof (struct unwind_table_entry));
420
 
421
          /* Convert offset & size into region_start and region_end.
422
             Stuff away the stub type into "reserved" fields.  */
423
          ui->table[index].region_start = bfd_get_32 (objfile->obfd,
424
                                                      (bfd_byte *) buf);
425
          ui->table[index].region_start += text_offset;
426
          buf += 4;
427
          ui->table[index].stub_unwind.stub_type = bfd_get_8 (objfile->obfd,
428
                                                          (bfd_byte *) buf);
429
          buf += 2;
430
          ui->table[index].region_end
431
            = ui->table[index].region_start + 4 *
432
            (bfd_get_16 (objfile->obfd, (bfd_byte *) buf) - 1);
433
          buf += 2;
434
        }
435
 
436
    }
437
 
438
  /* Unwind table needs to be kept sorted.  */
439
  qsort (ui->table, total_entries, sizeof (struct unwind_table_entry),
440
         compare_unwind_entries);
441
 
442
  /* Keep a pointer to the unwind information.  */
443
  obj_private = (struct hppa_objfile_private *)
444
                objfile_data (objfile, hppa_objfile_priv_data);
445
  if (obj_private == NULL)
446
    obj_private = hppa_init_objfile_priv_data (objfile);
447
 
448
  obj_private->unwind_info = ui;
449
}
450
 
451
/* Lookup the unwind (stack backtrace) info for the given PC.  We search all
452
   of the objfiles seeking the unwind table entry for this PC.  Each objfile
453
   contains a sorted list of struct unwind_table_entry.  Since we do a binary
454
   search of the unwind tables, we depend upon them to be sorted.  */
455
 
456
struct unwind_table_entry *
457
find_unwind_entry (CORE_ADDR pc)
458
{
459
  int first, middle, last;
460
  struct objfile *objfile;
461
  struct hppa_objfile_private *priv;
462
 
463
  if (hppa_debug)
464
    fprintf_unfiltered (gdb_stdlog, "{ find_unwind_entry 0x%s -> ",
465
                        paddr_nz (pc));
466
 
467
  /* A function at address 0?  Not in HP-UX! */
468
  if (pc == (CORE_ADDR) 0)
469
    {
470
      if (hppa_debug)
471
        fprintf_unfiltered (gdb_stdlog, "NULL }\n");
472
      return NULL;
473
    }
474
 
475
  ALL_OBJFILES (objfile)
476
  {
477
    struct hppa_unwind_info *ui;
478
    ui = NULL;
479
    priv = objfile_data (objfile, hppa_objfile_priv_data);
480
    if (priv)
481
      ui = ((struct hppa_objfile_private *) priv)->unwind_info;
482
 
483
    if (!ui)
484
      {
485
        read_unwind_info (objfile);
486
        priv = objfile_data (objfile, hppa_objfile_priv_data);
487
        if (priv == NULL)
488
          error (_("Internal error reading unwind information."));
489
        ui = ((struct hppa_objfile_private *) priv)->unwind_info;
490
      }
491
 
492
    /* First, check the cache */
493
 
494
    if (ui->cache
495
        && pc >= ui->cache->region_start
496
        && pc <= ui->cache->region_end)
497
      {
498
        if (hppa_debug)
499
          fprintf_unfiltered (gdb_stdlog, "0x%s (cached) }\n",
500
            paddr_nz ((uintptr_t) ui->cache));
501
        return ui->cache;
502
      }
503
 
504
    /* Not in the cache, do a binary search */
505
 
506
    first = 0;
507
    last = ui->last;
508
 
509
    while (first <= last)
510
      {
511
        middle = (first + last) / 2;
512
        if (pc >= ui->table[middle].region_start
513
            && pc <= ui->table[middle].region_end)
514
          {
515
            ui->cache = &ui->table[middle];
516
            if (hppa_debug)
517
              fprintf_unfiltered (gdb_stdlog, "0x%s }\n",
518
                paddr_nz ((uintptr_t) ui->cache));
519
            return &ui->table[middle];
520
          }
521
 
522
        if (pc < ui->table[middle].region_start)
523
          last = middle - 1;
524
        else
525
          first = middle + 1;
526
      }
527
  }                             /* ALL_OBJFILES() */
528
 
529
  if (hppa_debug)
530
    fprintf_unfiltered (gdb_stdlog, "NULL (not found) }\n");
531
 
532
  return NULL;
533
}
534
 
535
/* The epilogue is defined here as the area either on the `bv' instruction
536
   itself or an instruction which destroys the function's stack frame.
537
 
538
   We do not assume that the epilogue is at the end of a function as we can
539
   also have return sequences in the middle of a function.  */
540
static int
541
hppa_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
542
{
543
  unsigned long status;
544
  unsigned int inst;
545
  char buf[4];
546
  int off;
547
 
548
  status = read_memory_nobpt (pc, buf, 4);
549
  if (status != 0)
550
    return 0;
551
 
552
  inst = extract_unsigned_integer (buf, 4);
553
 
554
  /* The most common way to perform a stack adjustment ldo X(sp),sp
555
     We are destroying a stack frame if the offset is negative.  */
556
  if ((inst & 0xffffc000) == 0x37de0000
557
      && hppa_extract_14 (inst) < 0)
558
    return 1;
559
 
560
  /* ldw,mb D(sp),X or ldd,mb D(sp),X */
561
  if (((inst & 0x0fc010e0) == 0x0fc010e0
562
       || (inst & 0x0fc010e0) == 0x0fc010e0)
563
      && hppa_extract_14 (inst) < 0)
564
    return 1;
565
 
566
  /* bv %r0(%rp) or bv,n %r0(%rp) */
567
  if (inst == 0xe840c000 || inst == 0xe840c002)
568
    return 1;
569
 
570
  return 0;
571
}
572
 
573
static const unsigned char *
574
hppa_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pc, int *len)
575
{
576
  static const unsigned char breakpoint[] = {0x00, 0x01, 0x00, 0x04};
577
  (*len) = sizeof (breakpoint);
578
  return breakpoint;
579
}
580
 
581
/* Return the name of a register.  */
582
 
583
static const char *
584
hppa32_register_name (struct gdbarch *gdbarch, int i)
585
{
586
  static char *names[] = {
587
    "flags",  "r1",      "rp",     "r3",
588
    "r4",     "r5",      "r6",     "r7",
589
    "r8",     "r9",      "r10",    "r11",
590
    "r12",    "r13",     "r14",    "r15",
591
    "r16",    "r17",     "r18",    "r19",
592
    "r20",    "r21",     "r22",    "r23",
593
    "r24",    "r25",     "r26",    "dp",
594
    "ret0",   "ret1",    "sp",     "r31",
595
    "sar",    "pcoqh",   "pcsqh",  "pcoqt",
596
    "pcsqt",  "eiem",    "iir",    "isr",
597
    "ior",    "ipsw",    "goto",   "sr4",
598
    "sr0",    "sr1",     "sr2",    "sr3",
599
    "sr5",    "sr6",     "sr7",    "cr0",
600
    "cr8",    "cr9",     "ccr",    "cr12",
601
    "cr13",   "cr24",    "cr25",   "cr26",
602
    "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
603
    "fpsr",    "fpe1",   "fpe2",   "fpe3",
604
    "fpe4",   "fpe5",    "fpe6",   "fpe7",
605
    "fr4",     "fr4R",   "fr5",    "fr5R",
606
    "fr6",    "fr6R",    "fr7",    "fr7R",
607
    "fr8",     "fr8R",   "fr9",    "fr9R",
608
    "fr10",   "fr10R",   "fr11",   "fr11R",
609
    "fr12",    "fr12R",  "fr13",   "fr13R",
610
    "fr14",   "fr14R",   "fr15",   "fr15R",
611
    "fr16",    "fr16R",  "fr17",   "fr17R",
612
    "fr18",   "fr18R",   "fr19",   "fr19R",
613
    "fr20",    "fr20R",  "fr21",   "fr21R",
614
    "fr22",   "fr22R",   "fr23",   "fr23R",
615
    "fr24",    "fr24R",  "fr25",   "fr25R",
616
    "fr26",   "fr26R",   "fr27",   "fr27R",
617
    "fr28",    "fr28R",  "fr29",   "fr29R",
618
    "fr30",   "fr30R",   "fr31",   "fr31R"
619
  };
620
  if (i < 0 || i >= (sizeof (names) / sizeof (*names)))
621
    return NULL;
622
  else
623
    return names[i];
624
}
625
 
626
static const char *
627
hppa64_register_name (struct gdbarch *gdbarch, int i)
628
{
629
  static char *names[] = {
630
    "flags",  "r1",      "rp",     "r3",
631
    "r4",     "r5",      "r6",     "r7",
632
    "r8",     "r9",      "r10",    "r11",
633
    "r12",    "r13",     "r14",    "r15",
634
    "r16",    "r17",     "r18",    "r19",
635
    "r20",    "r21",     "r22",    "r23",
636
    "r24",    "r25",     "r26",    "dp",
637
    "ret0",   "ret1",    "sp",     "r31",
638
    "sar",    "pcoqh",   "pcsqh",  "pcoqt",
639
    "pcsqt",  "eiem",    "iir",    "isr",
640
    "ior",    "ipsw",    "goto",   "sr4",
641
    "sr0",    "sr1",     "sr2",    "sr3",
642
    "sr5",    "sr6",     "sr7",    "cr0",
643
    "cr8",    "cr9",     "ccr",    "cr12",
644
    "cr13",   "cr24",    "cr25",   "cr26",
645
    "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
646
    "fpsr",    "fpe1",   "fpe2",   "fpe3",
647
    "fr4",    "fr5",     "fr6",    "fr7",
648
    "fr8",     "fr9",    "fr10",   "fr11",
649
    "fr12",   "fr13",    "fr14",   "fr15",
650
    "fr16",    "fr17",   "fr18",   "fr19",
651
    "fr20",   "fr21",    "fr22",   "fr23",
652
    "fr24",    "fr25",   "fr26",   "fr27",
653
    "fr28",  "fr29",    "fr30",   "fr31"
654
  };
655
  if (i < 0 || i >= (sizeof (names) / sizeof (*names)))
656
    return NULL;
657
  else
658
    return names[i];
659
}
660
 
661
static int
662
hppa64_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg)
663
{
664
  /* r0-r31 and sar map one-to-one.  */
665
  if (reg <= 32)
666
    return reg;
667
 
668
  /* fr4-fr31 are mapped from 72 in steps of 2.  */
669
  if (reg >= 72 || reg < 72 + 28 * 2)
670
    return HPPA64_FP4_REGNUM + (reg - 72) / 2;
671
 
672
  error ("Invalid DWARF register num %d.", reg);
673
  return -1;
674
}
675
 
676
/* This function pushes a stack frame with arguments as part of the
677
   inferior function calling mechanism.
678
 
679
   This is the version of the function for the 32-bit PA machines, in
680
   which later arguments appear at lower addresses.  (The stack always
681
   grows towards higher addresses.)
682
 
683
   We simply allocate the appropriate amount of stack space and put
684
   arguments into their proper slots.  */
685
 
686
static CORE_ADDR
687
hppa32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
688
                        struct regcache *regcache, CORE_ADDR bp_addr,
689
                        int nargs, struct value **args, CORE_ADDR sp,
690
                        int struct_return, CORE_ADDR struct_addr)
691
{
692
  /* Stack base address at which any pass-by-reference parameters are
693
     stored.  */
694
  CORE_ADDR struct_end = 0;
695
  /* Stack base address at which the first parameter is stored.  */
696
  CORE_ADDR param_end = 0;
697
 
698
  /* The inner most end of the stack after all the parameters have
699
     been pushed.  */
700
  CORE_ADDR new_sp = 0;
701
 
702
  /* Two passes.  First pass computes the location of everything,
703
     second pass writes the bytes out.  */
704
  int write_pass;
705
 
706
  /* Global pointer (r19) of the function we are trying to call.  */
707
  CORE_ADDR gp;
708
 
709
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
710
 
711
  for (write_pass = 0; write_pass < 2; write_pass++)
712
    {
713
      CORE_ADDR struct_ptr = 0;
714
      /* The first parameter goes into sp-36, each stack slot is 4-bytes.
715
         struct_ptr is adjusted for each argument below, so the first
716
         argument will end up at sp-36.  */
717
      CORE_ADDR param_ptr = 32;
718
      int i;
719
      int small_struct = 0;
720
 
721
      for (i = 0; i < nargs; i++)
722
        {
723
          struct value *arg = args[i];
724
          struct type *type = check_typedef (value_type (arg));
725
          /* The corresponding parameter that is pushed onto the
726
             stack, and [possibly] passed in a register.  */
727
          char param_val[8];
728
          int param_len;
729
          memset (param_val, 0, sizeof param_val);
730
          if (TYPE_LENGTH (type) > 8)
731
            {
732
              /* Large parameter, pass by reference.  Store the value
733
                 in "struct" area and then pass its address.  */
734
              param_len = 4;
735
              struct_ptr += align_up (TYPE_LENGTH (type), 8);
736
              if (write_pass)
737
                write_memory (struct_end - struct_ptr, value_contents (arg),
738
                              TYPE_LENGTH (type));
739
              store_unsigned_integer (param_val, 4, struct_end - struct_ptr);
740
            }
741
          else if (TYPE_CODE (type) == TYPE_CODE_INT
742
                   || TYPE_CODE (type) == TYPE_CODE_ENUM)
743
            {
744
              /* Integer value store, right aligned.  "unpack_long"
745
                 takes care of any sign-extension problems.  */
746
              param_len = align_up (TYPE_LENGTH (type), 4);
747
              store_unsigned_integer (param_val, param_len,
748
                                      unpack_long (type,
749
                                                   value_contents (arg)));
750
            }
751
          else if (TYPE_CODE (type) == TYPE_CODE_FLT)
752
            {
753
              /* Floating point value store, right aligned.  */
754
              param_len = align_up (TYPE_LENGTH (type), 4);
755
              memcpy (param_val, value_contents (arg), param_len);
756
            }
757
          else
758
            {
759
              param_len = align_up (TYPE_LENGTH (type), 4);
760
 
761
              /* Small struct value are stored right-aligned.  */
762
              memcpy (param_val + param_len - TYPE_LENGTH (type),
763
                      value_contents (arg), TYPE_LENGTH (type));
764
 
765
              /* Structures of size 5, 6 and 7 bytes are special in that
766
                 the higher-ordered word is stored in the lower-ordered
767
                 argument, and even though it is a 8-byte quantity the
768
                 registers need not be 8-byte aligned.  */
769
              if (param_len > 4 && param_len < 8)
770
                small_struct = 1;
771
            }
772
 
773
          param_ptr += param_len;
774
          if (param_len == 8 && !small_struct)
775
            param_ptr = align_up (param_ptr, 8);
776
 
777
          /* First 4 non-FP arguments are passed in gr26-gr23.
778
             First 4 32-bit FP arguments are passed in fr4L-fr7L.
779
             First 2 64-bit FP arguments are passed in fr5 and fr7.
780
 
781
             The rest go on the stack, starting at sp-36, towards lower
782
             addresses.  8-byte arguments must be aligned to a 8-byte
783
             stack boundary.  */
784
          if (write_pass)
785
            {
786
              write_memory (param_end - param_ptr, param_val, param_len);
787
 
788
              /* There are some cases when we don't know the type
789
                 expected by the callee (e.g. for variadic functions), so
790
                 pass the parameters in both general and fp regs.  */
791
              if (param_ptr <= 48)
792
                {
793
                  int grreg = 26 - (param_ptr - 36) / 4;
794
                  int fpLreg = 72 + (param_ptr - 36) / 4 * 2;
795
                  int fpreg = 74 + (param_ptr - 32) / 8 * 4;
796
 
797
                  regcache_cooked_write (regcache, grreg, param_val);
798
                  regcache_cooked_write (regcache, fpLreg, param_val);
799
 
800
                  if (param_len > 4)
801
                    {
802
                      regcache_cooked_write (regcache, grreg + 1,
803
                                             param_val + 4);
804
 
805
                      regcache_cooked_write (regcache, fpreg, param_val);
806
                      regcache_cooked_write (regcache, fpreg + 1,
807
                                             param_val + 4);
808
                    }
809
                }
810
            }
811
        }
812
 
813
      /* Update the various stack pointers.  */
814
      if (!write_pass)
815
        {
816
          struct_end = sp + align_up (struct_ptr, 64);
817
          /* PARAM_PTR already accounts for all the arguments passed
818
             by the user.  However, the ABI mandates minimum stack
819
             space allocations for outgoing arguments.  The ABI also
820
             mandates minimum stack alignments which we must
821
             preserve.  */
822
          param_end = struct_end + align_up (param_ptr, 64);
823
        }
824
    }
825
 
826
  /* If a structure has to be returned, set up register 28 to hold its
827
     address */
828
  if (struct_return)
829
    regcache_cooked_write_unsigned (regcache, 28, struct_addr);
830
 
831
  gp = tdep->find_global_pointer (gdbarch, function);
832
 
833
  if (gp != 0)
834
    regcache_cooked_write_unsigned (regcache, 19, gp);
835
 
836
  /* Set the return address.  */
837
  if (!gdbarch_push_dummy_code_p (gdbarch))
838
    regcache_cooked_write_unsigned (regcache, HPPA_RP_REGNUM, bp_addr);
839
 
840
  /* Update the Stack Pointer.  */
841
  regcache_cooked_write_unsigned (regcache, HPPA_SP_REGNUM, param_end);
842
 
843
  return param_end;
844
}
845
 
846
/* The 64-bit PA-RISC calling conventions are documented in "64-Bit
847
   Runtime Architecture for PA-RISC 2.0", which is distributed as part
848
   as of the HP-UX Software Transition Kit (STK).  This implementation
849
   is based on version 3.3, dated October 6, 1997.  */
850
 
851
/* Check whether TYPE is an "Integral or Pointer Scalar Type".  */
852
 
853
static int
854
hppa64_integral_or_pointer_p (const struct type *type)
855
{
856
  switch (TYPE_CODE (type))
857
    {
858
    case TYPE_CODE_INT:
859
    case TYPE_CODE_BOOL:
860
    case TYPE_CODE_CHAR:
861
    case TYPE_CODE_ENUM:
862
    case TYPE_CODE_RANGE:
863
      {
864
        int len = TYPE_LENGTH (type);
865
        return (len == 1 || len == 2 || len == 4 || len == 8);
866
      }
867
    case TYPE_CODE_PTR:
868
    case TYPE_CODE_REF:
869
      return (TYPE_LENGTH (type) == 8);
870
    default:
871
      break;
872
    }
873
 
874
  return 0;
875
}
876
 
877
/* Check whether TYPE is a "Floating Scalar Type".  */
878
 
879
static int
880
hppa64_floating_p (const struct type *type)
881
{
882
  switch (TYPE_CODE (type))
883
    {
884
    case TYPE_CODE_FLT:
885
      {
886
        int len = TYPE_LENGTH (type);
887
        return (len == 4 || len == 8 || len == 16);
888
      }
889
    default:
890
      break;
891
    }
892
 
893
  return 0;
894
}
895
 
896
/* If CODE points to a function entry address, try to look up the corresponding
897
   function descriptor and return its address instead.  If CODE is not a
898
   function entry address, then just return it unchanged.  */
899
static CORE_ADDR
900
hppa64_convert_code_addr_to_fptr (CORE_ADDR code)
901
{
902
  struct obj_section *sec, *opd;
903
 
904
  sec = find_pc_section (code);
905
 
906
  if (!sec)
907
    return code;
908
 
909
  /* If CODE is in a data section, assume it's already a fptr.  */
910
  if (!(sec->the_bfd_section->flags & SEC_CODE))
911
    return code;
912
 
913
  ALL_OBJFILE_OSECTIONS (sec->objfile, opd)
914
    {
915
      if (strcmp (opd->the_bfd_section->name, ".opd") == 0)
916
        break;
917
    }
918
 
919
  if (opd < sec->objfile->sections_end)
920
    {
921
      CORE_ADDR addr;
922
 
923
      for (addr = opd->addr; addr < opd->endaddr; addr += 2 * 8)
924
        {
925
          ULONGEST opdaddr;
926
          char tmp[8];
927
 
928
          if (target_read_memory (addr, tmp, sizeof (tmp)))
929
              break;
930
          opdaddr = extract_unsigned_integer (tmp, sizeof (tmp));
931
 
932
          if (opdaddr == code)
933
            return addr - 16;
934
        }
935
    }
936
 
937
  return code;
938
}
939
 
940
static CORE_ADDR
941
hppa64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
942
                        struct regcache *regcache, CORE_ADDR bp_addr,
943
                        int nargs, struct value **args, CORE_ADDR sp,
944
                        int struct_return, CORE_ADDR struct_addr)
945
{
946
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
947
  int i, offset = 0;
948
  CORE_ADDR gp;
949
 
950
  /* "The outgoing parameter area [...] must be aligned at a 16-byte
951
     boundary."  */
952
  sp = align_up (sp, 16);
953
 
954
  for (i = 0; i < nargs; i++)
955
    {
956
      struct value *arg = args[i];
957
      struct type *type = value_type (arg);
958
      int len = TYPE_LENGTH (type);
959
      const bfd_byte *valbuf;
960
      bfd_byte fptrbuf[8];
961
      int regnum;
962
 
963
      /* "Each parameter begins on a 64-bit (8-byte) boundary."  */
964
      offset = align_up (offset, 8);
965
 
966
      if (hppa64_integral_or_pointer_p (type))
967
        {
968
          /* "Integral scalar parameters smaller than 64 bits are
969
             padded on the left (i.e., the value is in the
970
             least-significant bits of the 64-bit storage unit, and
971
             the high-order bits are undefined)."  Therefore we can
972
             safely sign-extend them.  */
973
          if (len < 8)
974
            {
975
              arg = value_cast (builtin_type_int64, arg);
976
              len = 8;
977
            }
978
        }
979
      else if (hppa64_floating_p (type))
980
        {
981
          if (len > 8)
982
            {
983
              /* "Quad-precision (128-bit) floating-point scalar
984
                 parameters are aligned on a 16-byte boundary."  */
985
              offset = align_up (offset, 16);
986
 
987
              /* "Double-extended- and quad-precision floating-point
988
                 parameters within the first 64 bytes of the parameter
989
                 list are always passed in general registers."  */
990
            }
991
          else
992
            {
993
              if (len == 4)
994
                {
995
                  /* "Single-precision (32-bit) floating-point scalar
996
                     parameters are padded on the left with 32 bits of
997
                     garbage (i.e., the floating-point value is in the
998
                     least-significant 32 bits of a 64-bit storage
999
                     unit)."  */
1000
                  offset += 4;
1001
                }
1002
 
1003
              /* "Single- and double-precision floating-point
1004
                 parameters in this area are passed according to the
1005
                 available formal parameter information in a function
1006
                 prototype.  [...]  If no prototype is in scope,
1007
                 floating-point parameters must be passed both in the
1008
                 corresponding general registers and in the
1009
                 corresponding floating-point registers."  */
1010
              regnum = HPPA64_FP4_REGNUM + offset / 8;
1011
 
1012
              if (regnum < HPPA64_FP4_REGNUM + 8)
1013
                {
1014
                  /* "Single-precision floating-point parameters, when
1015
                     passed in floating-point registers, are passed in
1016
                     the right halves of the floating point registers;
1017
                     the left halves are unused."  */
1018
                  regcache_cooked_write_part (regcache, regnum, offset % 8,
1019
                                              len, value_contents (arg));
1020
                }
1021
            }
1022
        }
1023
      else
1024
        {
1025
          if (len > 8)
1026
            {
1027
              /* "Aggregates larger than 8 bytes are aligned on a
1028
                 16-byte boundary, possibly leaving an unused argument
1029
                 slot, which is filled with garbage. If necessary,
1030
                 they are padded on the right (with garbage), to a
1031
                 multiple of 8 bytes."  */
1032
              offset = align_up (offset, 16);
1033
            }
1034
        }
1035
 
1036
      /* If we are passing a function pointer, make sure we pass a function
1037
         descriptor instead of the function entry address.  */
1038
      if (TYPE_CODE (type) == TYPE_CODE_PTR
1039
          && TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC)
1040
        {
1041
          ULONGEST codeptr, fptr;
1042
 
1043
          codeptr = unpack_long (type, value_contents (arg));
1044
          fptr = hppa64_convert_code_addr_to_fptr (codeptr);
1045
          store_unsigned_integer (fptrbuf, TYPE_LENGTH (type), fptr);
1046
          valbuf = fptrbuf;
1047
        }
1048
      else
1049
        {
1050
          valbuf = value_contents (arg);
1051
        }
1052
 
1053
      /* Always store the argument in memory.  */
1054
      write_memory (sp + offset, valbuf, len);
1055
 
1056
      regnum = HPPA_ARG0_REGNUM - offset / 8;
1057
      while (regnum > HPPA_ARG0_REGNUM - 8 && len > 0)
1058
        {
1059
          regcache_cooked_write_part (regcache, regnum,
1060
                                      offset % 8, min (len, 8), valbuf);
1061
          offset += min (len, 8);
1062
          valbuf += min (len, 8);
1063
          len -= min (len, 8);
1064
          regnum--;
1065
        }
1066
 
1067
      offset += len;
1068
    }
1069
 
1070
  /* Set up GR29 (%ret1) to hold the argument pointer (ap).  */
1071
  regcache_cooked_write_unsigned (regcache, HPPA_RET1_REGNUM, sp + 64);
1072
 
1073
  /* Allocate the outgoing parameter area.  Make sure the outgoing
1074
     parameter area is multiple of 16 bytes in length.  */
1075
  sp += max (align_up (offset, 16), 64);
1076
 
1077
  /* Allocate 32-bytes of scratch space.  The documentation doesn't
1078
     mention this, but it seems to be needed.  */
1079
  sp += 32;
1080
 
1081
  /* Allocate the frame marker area.  */
1082
  sp += 16;
1083
 
1084
  /* If a structure has to be returned, set up GR 28 (%ret0) to hold
1085
     its address.  */
1086
  if (struct_return)
1087
    regcache_cooked_write_unsigned (regcache, HPPA_RET0_REGNUM, struct_addr);
1088
 
1089
  /* Set up GR27 (%dp) to hold the global pointer (gp).  */
1090
  gp = tdep->find_global_pointer (gdbarch, function);
1091
  if (gp != 0)
1092
    regcache_cooked_write_unsigned (regcache, HPPA_DP_REGNUM, gp);
1093
 
1094
  /* Set up GR2 (%rp) to hold the return pointer (rp).  */
1095
  if (!gdbarch_push_dummy_code_p (gdbarch))
1096
    regcache_cooked_write_unsigned (regcache, HPPA_RP_REGNUM, bp_addr);
1097
 
1098
  /* Set up GR30 to hold the stack pointer (sp).  */
1099
  regcache_cooked_write_unsigned (regcache, HPPA_SP_REGNUM, sp);
1100
 
1101
  return sp;
1102
}
1103
 
1104
 
1105
/* Handle 32/64-bit struct return conventions.  */
1106
 
1107
static enum return_value_convention
1108
hppa32_return_value (struct gdbarch *gdbarch,
1109
                     struct type *type, struct regcache *regcache,
1110
                     gdb_byte *readbuf, const gdb_byte *writebuf)
1111
{
1112
  if (TYPE_LENGTH (type) <= 2 * 4)
1113
    {
1114
      /* The value always lives in the right hand end of the register
1115
         (or register pair)?  */
1116
      int b;
1117
      int reg = TYPE_CODE (type) == TYPE_CODE_FLT ? HPPA_FP4_REGNUM : 28;
1118
      int part = TYPE_LENGTH (type) % 4;
1119
      /* The left hand register contains only part of the value,
1120
         transfer that first so that the rest can be xfered as entire
1121
         4-byte registers.  */
1122
      if (part > 0)
1123
        {
1124
          if (readbuf != NULL)
1125
            regcache_cooked_read_part (regcache, reg, 4 - part,
1126
                                       part, readbuf);
1127
          if (writebuf != NULL)
1128
            regcache_cooked_write_part (regcache, reg, 4 - part,
1129
                                        part, writebuf);
1130
          reg++;
1131
        }
1132
      /* Now transfer the remaining register values.  */
1133
      for (b = part; b < TYPE_LENGTH (type); b += 4)
1134
        {
1135
          if (readbuf != NULL)
1136
            regcache_cooked_read (regcache, reg, readbuf + b);
1137
          if (writebuf != NULL)
1138
            regcache_cooked_write (regcache, reg, writebuf + b);
1139
          reg++;
1140
        }
1141
      return RETURN_VALUE_REGISTER_CONVENTION;
1142
    }
1143
  else
1144
    return RETURN_VALUE_STRUCT_CONVENTION;
1145
}
1146
 
1147
static enum return_value_convention
1148
hppa64_return_value (struct gdbarch *gdbarch,
1149
                     struct type *type, struct regcache *regcache,
1150
                     gdb_byte *readbuf, const gdb_byte *writebuf)
1151
{
1152
  int len = TYPE_LENGTH (type);
1153
  int regnum, offset;
1154
 
1155
  if (len > 16)
1156
    {
1157
      /* All return values larget than 128 bits must be aggregate
1158
         return values.  */
1159
      gdb_assert (!hppa64_integral_or_pointer_p (type));
1160
      gdb_assert (!hppa64_floating_p (type));
1161
 
1162
      /* "Aggregate return values larger than 128 bits are returned in
1163
         a buffer allocated by the caller.  The address of the buffer
1164
         must be passed in GR 28."  */
1165
      return RETURN_VALUE_STRUCT_CONVENTION;
1166
    }
1167
 
1168
  if (hppa64_integral_or_pointer_p (type))
1169
    {
1170
      /* "Integral return values are returned in GR 28.  Values
1171
         smaller than 64 bits are padded on the left (with garbage)."  */
1172
      regnum = HPPA_RET0_REGNUM;
1173
      offset = 8 - len;
1174
    }
1175
  else if (hppa64_floating_p (type))
1176
    {
1177
      if (len > 8)
1178
        {
1179
          /* "Double-extended- and quad-precision floating-point
1180
             values are returned in GRs 28 and 29.  The sign,
1181
             exponent, and most-significant bits of the mantissa are
1182
             returned in GR 28; the least-significant bits of the
1183
             mantissa are passed in GR 29.  For double-extended
1184
             precision values, GR 29 is padded on the right with 48
1185
             bits of garbage."  */
1186
          regnum = HPPA_RET0_REGNUM;
1187
          offset = 0;
1188
        }
1189
      else
1190
        {
1191
          /* "Single-precision and double-precision floating-point
1192
             return values are returned in FR 4R (single precision) or
1193
             FR 4 (double-precision)."  */
1194
          regnum = HPPA64_FP4_REGNUM;
1195
          offset = 8 - len;
1196
        }
1197
    }
1198
  else
1199
    {
1200
      /* "Aggregate return values up to 64 bits in size are returned
1201
         in GR 28.  Aggregates smaller than 64 bits are left aligned
1202
         in the register; the pad bits on the right are undefined."
1203
 
1204
         "Aggregate return values between 65 and 128 bits are returned
1205
         in GRs 28 and 29.  The first 64 bits are placed in GR 28, and
1206
         the remaining bits are placed, left aligned, in GR 29.  The
1207
         pad bits on the right of GR 29 (if any) are undefined."  */
1208
      regnum = HPPA_RET0_REGNUM;
1209
      offset = 0;
1210
    }
1211
 
1212
  if (readbuf)
1213
    {
1214
      while (len > 0)
1215
        {
1216
          regcache_cooked_read_part (regcache, regnum, offset,
1217
                                     min (len, 8), readbuf);
1218
          readbuf += min (len, 8);
1219
          len -= min (len, 8);
1220
          regnum++;
1221
        }
1222
    }
1223
 
1224
  if (writebuf)
1225
    {
1226
      while (len > 0)
1227
        {
1228
          regcache_cooked_write_part (regcache, regnum, offset,
1229
                                      min (len, 8), writebuf);
1230
          writebuf += min (len, 8);
1231
          len -= min (len, 8);
1232
          regnum++;
1233
        }
1234
    }
1235
 
1236
  return RETURN_VALUE_REGISTER_CONVENTION;
1237
}
1238
 
1239
 
1240
static CORE_ADDR
1241
hppa32_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr,
1242
                                   struct target_ops *targ)
1243
{
1244
  if (addr & 2)
1245
    {
1246
      CORE_ADDR plabel = addr & ~3;
1247
      return read_memory_typed_address (plabel, builtin_type_void_func_ptr);
1248
    }
1249
 
1250
  return addr;
1251
}
1252
 
1253
static CORE_ADDR
1254
hppa32_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
1255
{
1256
  /* HP frames are 64-byte (or cache line) aligned (yes that's _byte_
1257
     and not _bit_)!  */
1258
  return align_up (addr, 64);
1259
}
1260
 
1261
/* Force all frames to 16-byte alignment.  Better safe than sorry.  */
1262
 
1263
static CORE_ADDR
1264
hppa64_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
1265
{
1266
  /* Just always 16-byte align.  */
1267
  return align_up (addr, 16);
1268
}
1269
 
1270
CORE_ADDR
1271
hppa_read_pc (struct regcache *regcache)
1272
{
1273
  ULONGEST ipsw;
1274
  ULONGEST pc;
1275
 
1276
  regcache_cooked_read_unsigned (regcache, HPPA_IPSW_REGNUM, &ipsw);
1277
  regcache_cooked_read_unsigned (regcache, HPPA_PCOQ_HEAD_REGNUM, &pc);
1278
 
1279
  /* If the current instruction is nullified, then we are effectively
1280
     still executing the previous instruction.  Pretend we are still
1281
     there.  This is needed when single stepping; if the nullified
1282
     instruction is on a different line, we don't want GDB to think
1283
     we've stepped onto that line.  */
1284
  if (ipsw & 0x00200000)
1285
    pc -= 4;
1286
 
1287
  return pc & ~0x3;
1288
}
1289
 
1290
void
1291
hppa_write_pc (struct regcache *regcache, CORE_ADDR pc)
1292
{
1293
  regcache_cooked_write_unsigned (regcache, HPPA_PCOQ_HEAD_REGNUM, pc);
1294
  regcache_cooked_write_unsigned (regcache, HPPA_PCOQ_TAIL_REGNUM, pc + 4);
1295
}
1296
 
1297
/* return the alignment of a type in bytes. Structures have the maximum
1298
   alignment required by their fields. */
1299
 
1300
static int
1301
hppa_alignof (struct type *type)
1302
{
1303
  int max_align, align, i;
1304
  CHECK_TYPEDEF (type);
1305
  switch (TYPE_CODE (type))
1306
    {
1307
    case TYPE_CODE_PTR:
1308
    case TYPE_CODE_INT:
1309
    case TYPE_CODE_FLT:
1310
      return TYPE_LENGTH (type);
1311
    case TYPE_CODE_ARRAY:
1312
      return hppa_alignof (TYPE_FIELD_TYPE (type, 0));
1313
    case TYPE_CODE_STRUCT:
1314
    case TYPE_CODE_UNION:
1315
      max_align = 1;
1316
      for (i = 0; i < TYPE_NFIELDS (type); i++)
1317
        {
1318
          /* Bit fields have no real alignment. */
1319
          /* if (!TYPE_FIELD_BITPOS (type, i)) */
1320
          if (!TYPE_FIELD_BITSIZE (type, i))    /* elz: this should be bitsize */
1321
            {
1322
              align = hppa_alignof (TYPE_FIELD_TYPE (type, i));
1323
              max_align = max (max_align, align);
1324
            }
1325
        }
1326
      return max_align;
1327
    default:
1328
      return 4;
1329
    }
1330
}
1331
 
1332
/* For the given instruction (INST), return any adjustment it makes
1333
   to the stack pointer or zero for no adjustment.
1334
 
1335
   This only handles instructions commonly found in prologues.  */
1336
 
1337
static int
1338
prologue_inst_adjust_sp (unsigned long inst)
1339
{
1340
  /* This must persist across calls.  */
1341
  static int save_high21;
1342
 
1343
  /* The most common way to perform a stack adjustment ldo X(sp),sp */
1344
  if ((inst & 0xffffc000) == 0x37de0000)
1345
    return hppa_extract_14 (inst);
1346
 
1347
  /* stwm X,D(sp) */
1348
  if ((inst & 0xffe00000) == 0x6fc00000)
1349
    return hppa_extract_14 (inst);
1350
 
1351
  /* std,ma X,D(sp) */
1352
  if ((inst & 0xffe00008) == 0x73c00008)
1353
    return (inst & 0x1 ? -1 << 13 : 0) | (((inst >> 4) & 0x3ff) << 3);
1354
 
1355
  /* addil high21,%r30; ldo low11,(%r1),%r30)
1356
     save high bits in save_high21 for later use.  */
1357
  if ((inst & 0xffe00000) == 0x2bc00000)
1358
    {
1359
      save_high21 = hppa_extract_21 (inst);
1360
      return 0;
1361
    }
1362
 
1363
  if ((inst & 0xffff0000) == 0x343e0000)
1364
    return save_high21 + hppa_extract_14 (inst);
1365
 
1366
  /* fstws as used by the HP compilers.  */
1367
  if ((inst & 0xffffffe0) == 0x2fd01220)
1368
    return hppa_extract_5_load (inst);
1369
 
1370
  /* No adjustment.  */
1371
  return 0;
1372
}
1373
 
1374
/* Return nonzero if INST is a branch of some kind, else return zero.  */
1375
 
1376
static int
1377
is_branch (unsigned long inst)
1378
{
1379
  switch (inst >> 26)
1380
    {
1381
    case 0x20:
1382
    case 0x21:
1383
    case 0x22:
1384
    case 0x23:
1385
    case 0x27:
1386
    case 0x28:
1387
    case 0x29:
1388
    case 0x2a:
1389
    case 0x2b:
1390
    case 0x2f:
1391
    case 0x30:
1392
    case 0x31:
1393
    case 0x32:
1394
    case 0x33:
1395
    case 0x38:
1396
    case 0x39:
1397
    case 0x3a:
1398
    case 0x3b:
1399
      return 1;
1400
 
1401
    default:
1402
      return 0;
1403
    }
1404
}
1405
 
1406
/* Return the register number for a GR which is saved by INST or
1407
   zero it INST does not save a GR.  */
1408
 
1409
static int
1410
inst_saves_gr (unsigned long inst)
1411
{
1412
  /* Does it look like a stw?  */
1413
  if ((inst >> 26) == 0x1a || (inst >> 26) == 0x1b
1414
      || (inst >> 26) == 0x1f
1415
      || ((inst >> 26) == 0x1f
1416
          && ((inst >> 6) == 0xa)))
1417
    return hppa_extract_5R_store (inst);
1418
 
1419
  /* Does it look like a std?  */
1420
  if ((inst >> 26) == 0x1c
1421
      || ((inst >> 26) == 0x03
1422
          && ((inst >> 6) & 0xf) == 0xb))
1423
    return hppa_extract_5R_store (inst);
1424
 
1425
  /* Does it look like a stwm?  GCC & HPC may use this in prologues. */
1426
  if ((inst >> 26) == 0x1b)
1427
    return hppa_extract_5R_store (inst);
1428
 
1429
  /* Does it look like sth or stb?  HPC versions 9.0 and later use these
1430
     too.  */
1431
  if ((inst >> 26) == 0x19 || (inst >> 26) == 0x18
1432
      || ((inst >> 26) == 0x3
1433
          && (((inst >> 6) & 0xf) == 0x8
1434
              || (inst >> 6) & 0xf) == 0x9))
1435
    return hppa_extract_5R_store (inst);
1436
 
1437
  return 0;
1438
}
1439
 
1440
/* Return the register number for a FR which is saved by INST or
1441
   zero it INST does not save a FR.
1442
 
1443
   Note we only care about full 64bit register stores (that's the only
1444
   kind of stores the prologue will use).
1445
 
1446
   FIXME: What about argument stores with the HP compiler in ANSI mode? */
1447
 
1448
static int
1449
inst_saves_fr (unsigned long inst)
1450
{
1451
  /* is this an FSTD ? */
1452
  if ((inst & 0xfc00dfc0) == 0x2c001200)
1453
    return hppa_extract_5r_store (inst);
1454
  if ((inst & 0xfc000002) == 0x70000002)
1455
    return hppa_extract_5R_store (inst);
1456
  /* is this an FSTW ? */
1457
  if ((inst & 0xfc00df80) == 0x24001200)
1458
    return hppa_extract_5r_store (inst);
1459
  if ((inst & 0xfc000002) == 0x7c000000)
1460
    return hppa_extract_5R_store (inst);
1461
  return 0;
1462
}
1463
 
1464
/* Advance PC across any function entry prologue instructions
1465
   to reach some "real" code.
1466
 
1467
   Use information in the unwind table to determine what exactly should
1468
   be in the prologue.  */
1469
 
1470
 
1471
static CORE_ADDR
1472
skip_prologue_hard_way (struct gdbarch *gdbarch, CORE_ADDR pc,
1473
                        int stop_before_branch)
1474
{
1475
  char buf[4];
1476
  CORE_ADDR orig_pc = pc;
1477
  unsigned long inst, stack_remaining, save_gr, save_fr, save_rp, save_sp;
1478
  unsigned long args_stored, status, i, restart_gr, restart_fr;
1479
  struct unwind_table_entry *u;
1480
  int final_iteration;
1481
 
1482
  restart_gr = 0;
1483
  restart_fr = 0;
1484
 
1485
restart:
1486
  u = find_unwind_entry (pc);
1487
  if (!u)
1488
    return pc;
1489
 
1490
  /* If we are not at the beginning of a function, then return now. */
1491
  if ((pc & ~0x3) != u->region_start)
1492
    return pc;
1493
 
1494
  /* This is how much of a frame adjustment we need to account for.  */
1495
  stack_remaining = u->Total_frame_size << 3;
1496
 
1497
  /* Magic register saves we want to know about.  */
1498
  save_rp = u->Save_RP;
1499
  save_sp = u->Save_SP;
1500
 
1501
  /* An indication that args may be stored into the stack.  Unfortunately
1502
     the HPUX compilers tend to set this in cases where no args were
1503
     stored too!.  */
1504
  args_stored = 1;
1505
 
1506
  /* Turn the Entry_GR field into a bitmask.  */
1507
  save_gr = 0;
1508
  for (i = 3; i < u->Entry_GR + 3; i++)
1509
    {
1510
      /* Frame pointer gets saved into a special location.  */
1511
      if (u->Save_SP && i == HPPA_FP_REGNUM)
1512
        continue;
1513
 
1514
      save_gr |= (1 << i);
1515
    }
1516
  save_gr &= ~restart_gr;
1517
 
1518
  /* Turn the Entry_FR field into a bitmask too.  */
1519
  save_fr = 0;
1520
  for (i = 12; i < u->Entry_FR + 12; i++)
1521
    save_fr |= (1 << i);
1522
  save_fr &= ~restart_fr;
1523
 
1524
  final_iteration = 0;
1525
 
1526
  /* Loop until we find everything of interest or hit a branch.
1527
 
1528
     For unoptimized GCC code and for any HP CC code this will never ever
1529
     examine any user instructions.
1530
 
1531
     For optimzied GCC code we're faced with problems.  GCC will schedule
1532
     its prologue and make prologue instructions available for delay slot
1533
     filling.  The end result is user code gets mixed in with the prologue
1534
     and a prologue instruction may be in the delay slot of the first branch
1535
     or call.
1536
 
1537
     Some unexpected things are expected with debugging optimized code, so
1538
     we allow this routine to walk past user instructions in optimized
1539
     GCC code.  */
1540
  while (save_gr || save_fr || save_rp || save_sp || stack_remaining > 0
1541
         || args_stored)
1542
    {
1543
      unsigned int reg_num;
1544
      unsigned long old_stack_remaining, old_save_gr, old_save_fr;
1545
      unsigned long old_save_rp, old_save_sp, next_inst;
1546
 
1547
      /* Save copies of all the triggers so we can compare them later
1548
         (only for HPC).  */
1549
      old_save_gr = save_gr;
1550
      old_save_fr = save_fr;
1551
      old_save_rp = save_rp;
1552
      old_save_sp = save_sp;
1553
      old_stack_remaining = stack_remaining;
1554
 
1555
      status = read_memory_nobpt (pc, buf, 4);
1556
      inst = extract_unsigned_integer (buf, 4);
1557
 
1558
      /* Yow! */
1559
      if (status != 0)
1560
        return pc;
1561
 
1562
      /* Note the interesting effects of this instruction.  */
1563
      stack_remaining -= prologue_inst_adjust_sp (inst);
1564
 
1565
      /* There are limited ways to store the return pointer into the
1566
         stack.  */
1567
      if (inst == 0x6bc23fd9 || inst == 0x0fc212c1 || inst == 0x73c23fe1)
1568
        save_rp = 0;
1569
 
1570
      /* These are the only ways we save SP into the stack.  At this time
1571
         the HP compilers never bother to save SP into the stack.  */
1572
      if ((inst & 0xffffc000) == 0x6fc10000
1573
          || (inst & 0xffffc00c) == 0x73c10008)
1574
        save_sp = 0;
1575
 
1576
      /* Are we loading some register with an offset from the argument
1577
         pointer?  */
1578
      if ((inst & 0xffe00000) == 0x37a00000
1579
          || (inst & 0xffffffe0) == 0x081d0240)
1580
        {
1581
          pc += 4;
1582
          continue;
1583
        }
1584
 
1585
      /* Account for general and floating-point register saves.  */
1586
      reg_num = inst_saves_gr (inst);
1587
      save_gr &= ~(1 << reg_num);
1588
 
1589
      /* Ugh.  Also account for argument stores into the stack.
1590
         Unfortunately args_stored only tells us that some arguments
1591
         where stored into the stack.  Not how many or what kind!
1592
 
1593
         This is a kludge as on the HP compiler sets this bit and it
1594
         never does prologue scheduling.  So once we see one, skip past
1595
         all of them.   We have similar code for the fp arg stores below.
1596
 
1597
         FIXME.  Can still die if we have a mix of GR and FR argument
1598
         stores!  */
1599
      if (reg_num >= (gdbarch_ptr_bit (gdbarch) == 64 ? 19 : 23)
1600
          && reg_num <= 26)
1601
        {
1602
          while (reg_num >= (gdbarch_ptr_bit (gdbarch) == 64 ? 19 : 23)
1603
                 && reg_num <= 26)
1604
            {
1605
              pc += 4;
1606
              status = read_memory_nobpt (pc, buf, 4);
1607
              inst = extract_unsigned_integer (buf, 4);
1608
              if (status != 0)
1609
                return pc;
1610
              reg_num = inst_saves_gr (inst);
1611
            }
1612
          args_stored = 0;
1613
          continue;
1614
        }
1615
 
1616
      reg_num = inst_saves_fr (inst);
1617
      save_fr &= ~(1 << reg_num);
1618
 
1619
      status = read_memory_nobpt (pc + 4, buf, 4);
1620
      next_inst = extract_unsigned_integer (buf, 4);
1621
 
1622
      /* Yow! */
1623
      if (status != 0)
1624
        return pc;
1625
 
1626
      /* We've got to be read to handle the ldo before the fp register
1627
         save.  */
1628
      if ((inst & 0xfc000000) == 0x34000000
1629
          && inst_saves_fr (next_inst) >= 4
1630
          && inst_saves_fr (next_inst)
1631
               <= (gdbarch_ptr_bit (gdbarch) == 64 ? 11 : 7))
1632
        {
1633
          /* So we drop into the code below in a reasonable state.  */
1634
          reg_num = inst_saves_fr (next_inst);
1635
          pc -= 4;
1636
        }
1637
 
1638
      /* Ugh.  Also account for argument stores into the stack.
1639
         This is a kludge as on the HP compiler sets this bit and it
1640
         never does prologue scheduling.  So once we see one, skip past
1641
         all of them.  */
1642
      if (reg_num >= 4
1643
          && reg_num <= (gdbarch_ptr_bit (gdbarch) == 64 ? 11 : 7))
1644
        {
1645
          while (reg_num >= 4
1646
                 && reg_num
1647
                      <= (gdbarch_ptr_bit (gdbarch) == 64 ? 11 : 7))
1648
            {
1649
              pc += 8;
1650
              status = read_memory_nobpt (pc, buf, 4);
1651
              inst = extract_unsigned_integer (buf, 4);
1652
              if (status != 0)
1653
                return pc;
1654
              if ((inst & 0xfc000000) != 0x34000000)
1655
                break;
1656
              status = read_memory_nobpt (pc + 4, buf, 4);
1657
              next_inst = extract_unsigned_integer (buf, 4);
1658
              if (status != 0)
1659
                return pc;
1660
              reg_num = inst_saves_fr (next_inst);
1661
            }
1662
          args_stored = 0;
1663
          continue;
1664
        }
1665
 
1666
      /* Quit if we hit any kind of branch.  This can happen if a prologue
1667
         instruction is in the delay slot of the first call/branch.  */
1668
      if (is_branch (inst) && stop_before_branch)
1669
        break;
1670
 
1671
      /* What a crock.  The HP compilers set args_stored even if no
1672
         arguments were stored into the stack (boo hiss).  This could
1673
         cause this code to then skip a bunch of user insns (up to the
1674
         first branch).
1675
 
1676
         To combat this we try to identify when args_stored was bogusly
1677
         set and clear it.   We only do this when args_stored is nonzero,
1678
         all other resources are accounted for, and nothing changed on
1679
         this pass.  */
1680
      if (args_stored
1681
       && !(save_gr || save_fr || save_rp || save_sp || stack_remaining > 0)
1682
          && old_save_gr == save_gr && old_save_fr == save_fr
1683
          && old_save_rp == save_rp && old_save_sp == save_sp
1684
          && old_stack_remaining == stack_remaining)
1685
        break;
1686
 
1687
      /* Bump the PC.  */
1688
      pc += 4;
1689
 
1690
      /* !stop_before_branch, so also look at the insn in the delay slot
1691
         of the branch.  */
1692
      if (final_iteration)
1693
        break;
1694
      if (is_branch (inst))
1695
        final_iteration = 1;
1696
    }
1697
 
1698
  /* We've got a tenative location for the end of the prologue.  However
1699
     because of limitations in the unwind descriptor mechanism we may
1700
     have went too far into user code looking for the save of a register
1701
     that does not exist.  So, if there registers we expected to be saved
1702
     but never were, mask them out and restart.
1703
 
1704
     This should only happen in optimized code, and should be very rare.  */
1705
  if (save_gr || (save_fr && !(restart_fr || restart_gr)))
1706
    {
1707
      pc = orig_pc;
1708
      restart_gr = save_gr;
1709
      restart_fr = save_fr;
1710
      goto restart;
1711
    }
1712
 
1713
  return pc;
1714
}
1715
 
1716
 
1717
/* Return the address of the PC after the last prologue instruction if
1718
   we can determine it from the debug symbols.  Else return zero.  */
1719
 
1720
static CORE_ADDR
1721
after_prologue (CORE_ADDR pc)
1722
{
1723
  struct symtab_and_line sal;
1724
  CORE_ADDR func_addr, func_end;
1725
  struct symbol *f;
1726
 
1727
  /* If we can not find the symbol in the partial symbol table, then
1728
     there is no hope we can determine the function's start address
1729
     with this code.  */
1730
  if (!find_pc_partial_function (pc, NULL, &func_addr, &func_end))
1731
    return 0;
1732
 
1733
  /* Get the line associated with FUNC_ADDR.  */
1734
  sal = find_pc_line (func_addr, 0);
1735
 
1736
  /* There are only two cases to consider.  First, the end of the source line
1737
     is within the function bounds.  In that case we return the end of the
1738
     source line.  Second is the end of the source line extends beyond the
1739
     bounds of the current function.  We need to use the slow code to
1740
     examine instructions in that case.
1741
 
1742
     Anything else is simply a bug elsewhere.  Fixing it here is absolutely
1743
     the wrong thing to do.  In fact, it should be entirely possible for this
1744
     function to always return zero since the slow instruction scanning code
1745
     is supposed to *always* work.  If it does not, then it is a bug.  */
1746
  if (sal.end < func_end)
1747
    return sal.end;
1748
  else
1749
    return 0;
1750
}
1751
 
1752
/* To skip prologues, I use this predicate.  Returns either PC itself
1753
   if the code at PC does not look like a function prologue; otherwise
1754
   returns an address that (if we're lucky) follows the prologue.
1755
 
1756
   hppa_skip_prologue is called by gdb to place a breakpoint in a function.
1757
   It doesn't necessarily skips all the insns in the prologue. In fact
1758
   we might not want to skip all the insns because a prologue insn may
1759
   appear in the delay slot of the first branch, and we don't want to
1760
   skip over the branch in that case.  */
1761
 
1762
static CORE_ADDR
1763
hppa_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
1764
{
1765
  unsigned long inst;
1766
  int offset;
1767
  CORE_ADDR post_prologue_pc;
1768
  char buf[4];
1769
 
1770
  /* See if we can determine the end of the prologue via the symbol table.
1771
     If so, then return either PC, or the PC after the prologue, whichever
1772
     is greater.  */
1773
 
1774
  post_prologue_pc = after_prologue (pc);
1775
 
1776
  /* If after_prologue returned a useful address, then use it.  Else
1777
     fall back on the instruction skipping code.
1778
 
1779
     Some folks have claimed this causes problems because the breakpoint
1780
     may be the first instruction of the prologue.  If that happens, then
1781
     the instruction skipping code has a bug that needs to be fixed.  */
1782
  if (post_prologue_pc != 0)
1783
    return max (pc, post_prologue_pc);
1784
  else
1785
    return (skip_prologue_hard_way (gdbarch, pc, 1));
1786
}
1787
 
1788
/* Return an unwind entry that falls within the frame's code block.  */
1789
static struct unwind_table_entry *
1790
hppa_find_unwind_entry_in_block (struct frame_info *f)
1791
{
1792
  CORE_ADDR pc = frame_unwind_address_in_block (f, NORMAL_FRAME);
1793
 
1794
  /* FIXME drow/20070101: Calling gdbarch_addr_bits_remove on the
1795
     result of frame_unwind_address_in_block implies a problem.
1796
     The bits should have been removed earlier, before the return
1797
     value of frame_pc_unwind.  That might be happening already;
1798
     if it isn't, it should be fixed.  Then this call can be
1799
     removed.  */
1800
  pc = gdbarch_addr_bits_remove (get_frame_arch (f), pc);
1801
  return find_unwind_entry (pc);
1802
}
1803
 
1804
struct hppa_frame_cache
1805
{
1806
  CORE_ADDR base;
1807
  struct trad_frame_saved_reg *saved_regs;
1808
};
1809
 
1810
static struct hppa_frame_cache *
1811
hppa_frame_cache (struct frame_info *next_frame, void **this_cache)
1812
{
1813
  struct gdbarch *gdbarch = get_frame_arch (next_frame);
1814
  struct hppa_frame_cache *cache;
1815
  long saved_gr_mask;
1816
  long saved_fr_mask;
1817
  CORE_ADDR this_sp;
1818
  long frame_size;
1819
  struct unwind_table_entry *u;
1820
  CORE_ADDR prologue_end;
1821
  int fp_in_r1 = 0;
1822
  int i;
1823
 
1824
  if (hppa_debug)
1825
    fprintf_unfiltered (gdb_stdlog, "{ hppa_frame_cache (frame=%d) -> ",
1826
      frame_relative_level(next_frame));
1827
 
1828
  if ((*this_cache) != NULL)
1829
    {
1830
      if (hppa_debug)
1831
        fprintf_unfiltered (gdb_stdlog, "base=0x%s (cached) }",
1832
          paddr_nz (((struct hppa_frame_cache *)*this_cache)->base));
1833
      return (*this_cache);
1834
    }
1835
  cache = FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache);
1836
  (*this_cache) = cache;
1837
  cache->saved_regs = trad_frame_alloc_saved_regs (next_frame);
1838
 
1839
  /* Yow! */
1840
  u = hppa_find_unwind_entry_in_block (next_frame);
1841
  if (!u)
1842
    {
1843
      if (hppa_debug)
1844
        fprintf_unfiltered (gdb_stdlog, "base=NULL (no unwind entry) }");
1845
      return (*this_cache);
1846
    }
1847
 
1848
  /* Turn the Entry_GR field into a bitmask.  */
1849
  saved_gr_mask = 0;
1850
  for (i = 3; i < u->Entry_GR + 3; i++)
1851
    {
1852
      /* Frame pointer gets saved into a special location.  */
1853
      if (u->Save_SP && i == HPPA_FP_REGNUM)
1854
        continue;
1855
 
1856
      saved_gr_mask |= (1 << i);
1857
    }
1858
 
1859
  /* Turn the Entry_FR field into a bitmask too.  */
1860
  saved_fr_mask = 0;
1861
  for (i = 12; i < u->Entry_FR + 12; i++)
1862
    saved_fr_mask |= (1 << i);
1863
 
1864
  /* Loop until we find everything of interest or hit a branch.
1865
 
1866
     For unoptimized GCC code and for any HP CC code this will never ever
1867
     examine any user instructions.
1868
 
1869
     For optimized GCC code we're faced with problems.  GCC will schedule
1870
     its prologue and make prologue instructions available for delay slot
1871
     filling.  The end result is user code gets mixed in with the prologue
1872
     and a prologue instruction may be in the delay slot of the first branch
1873
     or call.
1874
 
1875
     Some unexpected things are expected with debugging optimized code, so
1876
     we allow this routine to walk past user instructions in optimized
1877
     GCC code.  */
1878
  {
1879
    int final_iteration = 0;
1880
    CORE_ADDR pc, start_pc, end_pc;
1881
    int looking_for_sp = u->Save_SP;
1882
    int looking_for_rp = u->Save_RP;
1883
    int fp_loc = -1;
1884
 
1885
    /* We have to use skip_prologue_hard_way instead of just
1886
       skip_prologue_using_sal, in case we stepped into a function without
1887
       symbol information.  hppa_skip_prologue also bounds the returned
1888
       pc by the passed in pc, so it will not return a pc in the next
1889
       function.
1890
 
1891
       We used to call hppa_skip_prologue to find the end of the prologue,
1892
       but if some non-prologue instructions get scheduled into the prologue,
1893
       and the program is compiled with debug information, the "easy" way
1894
       in hppa_skip_prologue will return a prologue end that is too early
1895
       for us to notice any potential frame adjustments.  */
1896
 
1897
    /* We used to use frame_func_unwind () to locate the beginning of the
1898
       function to pass to skip_prologue ().  However, when objects are
1899
       compiled without debug symbols, frame_func_unwind can return the wrong
1900
       function (or 0).  We can do better than that by using unwind records.
1901
       This only works if the Region_description of the unwind record
1902
       indicates that it includes the entry point of the function.
1903
       HP compilers sometimes generate unwind records for regions that
1904
       do not include the entry or exit point of a function.  GNU tools
1905
       do not do this.  */
1906
 
1907
    if ((u->Region_description & 0x2) == 0)
1908
      start_pc = u->region_start;
1909
    else
1910
      start_pc = frame_func_unwind (next_frame, NORMAL_FRAME);
1911
 
1912
    prologue_end = skip_prologue_hard_way (gdbarch, start_pc, 0);
1913
    end_pc = frame_pc_unwind (next_frame);
1914
 
1915
    if (prologue_end != 0 && end_pc > prologue_end)
1916
      end_pc = prologue_end;
1917
 
1918
    frame_size = 0;
1919
 
1920
    for (pc = start_pc;
1921
         ((saved_gr_mask || saved_fr_mask
1922
           || looking_for_sp || looking_for_rp
1923
           || frame_size < (u->Total_frame_size << 3))
1924
          && pc < end_pc);
1925
         pc += 4)
1926
      {
1927
        int reg;
1928
        char buf4[4];
1929
        long inst;
1930
 
1931
        if (!safe_frame_unwind_memory (next_frame, pc, buf4,
1932
                                       sizeof buf4))
1933
          {
1934
            error (_("Cannot read instruction at 0x%s."), paddr_nz (pc));
1935
            return (*this_cache);
1936
          }
1937
 
1938
        inst = extract_unsigned_integer (buf4, sizeof buf4);
1939
 
1940
        /* Note the interesting effects of this instruction.  */
1941
        frame_size += prologue_inst_adjust_sp (inst);
1942
 
1943
        /* There are limited ways to store the return pointer into the
1944
           stack.  */
1945
        if (inst == 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
1946
          {
1947
            looking_for_rp = 0;
1948
            cache->saved_regs[HPPA_RP_REGNUM].addr = -20;
1949
          }
1950
        else if (inst == 0x6bc23fd1) /* stw rp,-0x18(sr0,sp) */
1951
          {
1952
            looking_for_rp = 0;
1953
            cache->saved_regs[HPPA_RP_REGNUM].addr = -24;
1954
          }
1955
        else if (inst == 0x0fc212c1
1956
                 || inst == 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
1957
          {
1958
            looking_for_rp = 0;
1959
            cache->saved_regs[HPPA_RP_REGNUM].addr = -16;
1960
          }
1961
 
1962
        /* Check to see if we saved SP into the stack.  This also
1963
           happens to indicate the location of the saved frame
1964
           pointer.  */
1965
        if ((inst & 0xffffc000) == 0x6fc10000  /* stw,ma r1,N(sr0,sp) */
1966
            || (inst & 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
1967
          {
1968
            looking_for_sp = 0;
1969
            cache->saved_regs[HPPA_FP_REGNUM].addr = 0;
1970
          }
1971
        else if (inst == 0x08030241) /* copy %r3, %r1 */
1972
          {
1973
            fp_in_r1 = 1;
1974
          }
1975
 
1976
        /* Account for general and floating-point register saves.  */
1977
        reg = inst_saves_gr (inst);
1978
        if (reg >= 3 && reg <= 18
1979
            && (!u->Save_SP || reg != HPPA_FP_REGNUM))
1980
          {
1981
            saved_gr_mask &= ~(1 << reg);
1982
            if ((inst >> 26) == 0x1b && hppa_extract_14 (inst) >= 0)
1983
              /* stwm with a positive displacement is a _post_
1984
                 _modify_.  */
1985
              cache->saved_regs[reg].addr = 0;
1986
            else if ((inst & 0xfc00000c) == 0x70000008)
1987
              /* A std has explicit post_modify forms.  */
1988
              cache->saved_regs[reg].addr = 0;
1989
            else
1990
              {
1991
                CORE_ADDR offset;
1992
 
1993
                if ((inst >> 26) == 0x1c)
1994
                  offset = (inst & 0x1 ? -1 << 13 : 0) | (((inst >> 4) & 0x3ff) << 3);
1995
                else if ((inst >> 26) == 0x03)
1996
                  offset = hppa_low_hppa_sign_extend (inst & 0x1f, 5);
1997
                else
1998
                  offset = hppa_extract_14 (inst);
1999
 
2000
                /* Handle code with and without frame pointers.  */
2001
                if (u->Save_SP)
2002
                  cache->saved_regs[reg].addr = offset;
2003
                else
2004
                  cache->saved_regs[reg].addr = (u->Total_frame_size << 3) + offset;
2005
              }
2006
          }
2007
 
2008
        /* GCC handles callee saved FP regs a little differently.
2009
 
2010
           It emits an instruction to put the value of the start of
2011
           the FP store area into %r1.  It then uses fstds,ma with a
2012
           basereg of %r1 for the stores.
2013
 
2014
           HP CC emits them at the current stack pointer modifying the
2015
           stack pointer as it stores each register.  */
2016
 
2017
        /* ldo X(%r3),%r1 or ldo X(%r30),%r1.  */
2018
        if ((inst & 0xffffc000) == 0x34610000
2019
            || (inst & 0xffffc000) == 0x37c10000)
2020
          fp_loc = hppa_extract_14 (inst);
2021
 
2022
        reg = inst_saves_fr (inst);
2023
        if (reg >= 12 && reg <= 21)
2024
          {
2025
            /* Note +4 braindamage below is necessary because the FP
2026
               status registers are internally 8 registers rather than
2027
               the expected 4 registers.  */
2028
            saved_fr_mask &= ~(1 << reg);
2029
            if (fp_loc == -1)
2030
              {
2031
                /* 1st HP CC FP register store.  After this
2032
                   instruction we've set enough state that the GCC and
2033
                   HPCC code are both handled in the same manner.  */
2034
                cache->saved_regs[reg + HPPA_FP4_REGNUM + 4].addr = 0;
2035
                fp_loc = 8;
2036
              }
2037
            else
2038
              {
2039
                cache->saved_regs[reg + HPPA_FP0_REGNUM + 4].addr = fp_loc;
2040
                fp_loc += 8;
2041
              }
2042
          }
2043
 
2044
        /* Quit if we hit any kind of branch the previous iteration. */
2045
        if (final_iteration)
2046
          break;
2047
        /* We want to look precisely one instruction beyond the branch
2048
           if we have not found everything yet.  */
2049
        if (is_branch (inst))
2050
          final_iteration = 1;
2051
      }
2052
  }
2053
 
2054
  {
2055
    /* The frame base always represents the value of %sp at entry to
2056
       the current function (and is thus equivalent to the "saved"
2057
       stack pointer.  */
2058
    CORE_ADDR this_sp = frame_unwind_register_unsigned (next_frame, HPPA_SP_REGNUM);
2059
    CORE_ADDR fp;
2060
 
2061
    if (hppa_debug)
2062
      fprintf_unfiltered (gdb_stdlog, " (this_sp=0x%s, pc=0x%s, "
2063
                          "prologue_end=0x%s) ",
2064
                          paddr_nz (this_sp),
2065
                          paddr_nz (frame_pc_unwind (next_frame)),
2066
                          paddr_nz (prologue_end));
2067
 
2068
     /* Check to see if a frame pointer is available, and use it for
2069
        frame unwinding if it is.
2070
 
2071
        There are some situations where we need to rely on the frame
2072
        pointer to do stack unwinding.  For example, if a function calls
2073
        alloca (), the stack pointer can get adjusted inside the body of
2074
        the function.  In this case, the ABI requires that the compiler
2075
        maintain a frame pointer for the function.
2076
 
2077
        The unwind record has a flag (alloca_frame) that indicates that
2078
        a function has a variable frame; unfortunately, gcc/binutils
2079
        does not set this flag.  Instead, whenever a frame pointer is used
2080
        and saved on the stack, the Save_SP flag is set.  We use this to
2081
        decide whether to use the frame pointer for unwinding.
2082
 
2083
        TODO: For the HP compiler, maybe we should use the alloca_frame flag
2084
        instead of Save_SP.  */
2085
 
2086
     fp = frame_unwind_register_unsigned (next_frame, HPPA_FP_REGNUM);
2087
 
2088
     if (u->alloca_frame)
2089
       fp -= u->Total_frame_size << 3;
2090
 
2091
     if (frame_pc_unwind (next_frame) >= prologue_end
2092
         && (u->Save_SP || u->alloca_frame) && fp != 0)
2093
      {
2094
        cache->base = fp;
2095
 
2096
        if (hppa_debug)
2097
          fprintf_unfiltered (gdb_stdlog, " (base=0x%s) [frame pointer]",
2098
            paddr_nz (cache->base));
2099
      }
2100
     else if (u->Save_SP
2101
              && trad_frame_addr_p (cache->saved_regs, HPPA_SP_REGNUM))
2102
      {
2103
            /* Both we're expecting the SP to be saved and the SP has been
2104
               saved.  The entry SP value is saved at this frame's SP
2105
               address.  */
2106
            cache->base = read_memory_integer
2107
                            (this_sp, gdbarch_ptr_bit (gdbarch) / 8);
2108
 
2109
            if (hppa_debug)
2110
              fprintf_unfiltered (gdb_stdlog, " (base=0x%s) [saved]",
2111
                                  paddr_nz (cache->base));
2112
      }
2113
    else
2114
      {
2115
        /* The prologue has been slowly allocating stack space.  Adjust
2116
           the SP back.  */
2117
        cache->base = this_sp - frame_size;
2118
        if (hppa_debug)
2119
          fprintf_unfiltered (gdb_stdlog, " (base=0x%s) [unwind adjust]",
2120
                              paddr_nz (cache->base));
2121
 
2122
      }
2123
    trad_frame_set_value (cache->saved_regs, HPPA_SP_REGNUM, cache->base);
2124
  }
2125
 
2126
  /* The PC is found in the "return register", "Millicode" uses "r31"
2127
     as the return register while normal code uses "rp".  */
2128
  if (u->Millicode)
2129
    {
2130
      if (trad_frame_addr_p (cache->saved_regs, 31))
2131
        {
2132
          cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] = cache->saved_regs[31];
2133
          if (hppa_debug)
2134
            fprintf_unfiltered (gdb_stdlog, " (pc=r31) [stack] } ");
2135
        }
2136
      else
2137
        {
2138
          ULONGEST r31 = frame_unwind_register_unsigned (next_frame, 31);
2139
          trad_frame_set_value (cache->saved_regs, HPPA_PCOQ_HEAD_REGNUM, r31);
2140
          if (hppa_debug)
2141
            fprintf_unfiltered (gdb_stdlog, " (pc=r31) [frame] } ");
2142
        }
2143
    }
2144
  else
2145
    {
2146
      if (trad_frame_addr_p (cache->saved_regs, HPPA_RP_REGNUM))
2147
        {
2148
          cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] =
2149
            cache->saved_regs[HPPA_RP_REGNUM];
2150
          if (hppa_debug)
2151
            fprintf_unfiltered (gdb_stdlog, " (pc=rp) [stack] } ");
2152
        }
2153
      else
2154
        {
2155
          ULONGEST rp = frame_unwind_register_unsigned (next_frame, HPPA_RP_REGNUM);
2156
          trad_frame_set_value (cache->saved_regs, HPPA_PCOQ_HEAD_REGNUM, rp);
2157
          if (hppa_debug)
2158
            fprintf_unfiltered (gdb_stdlog, " (pc=rp) [frame] } ");
2159
        }
2160
    }
2161
 
2162
  /* If Save_SP is set, then we expect the frame pointer to be saved in the
2163
     frame.  However, there is a one-insn window where we haven't saved it
2164
     yet, but we've already clobbered it.  Detect this case and fix it up.
2165
 
2166
     The prologue sequence for frame-pointer functions is:
2167
        0: stw %rp, -20(%sp)
2168
        4: copy %r3, %r1
2169
        8: copy %sp, %r3
2170
        c: stw,ma %r1, XX(%sp)
2171
 
2172
     So if we are at offset c, the r3 value that we want is not yet saved
2173
     on the stack, but it's been overwritten.  The prologue analyzer will
2174
     set fp_in_r1 when it sees the copy insn so we know to get the value
2175
     from r1 instead.  */
2176
  if (u->Save_SP && !trad_frame_addr_p (cache->saved_regs, HPPA_FP_REGNUM)
2177
      && fp_in_r1)
2178
    {
2179
      ULONGEST r1 = frame_unwind_register_unsigned (next_frame, 1);
2180
      trad_frame_set_value (cache->saved_regs, HPPA_FP_REGNUM, r1);
2181
    }
2182
 
2183
  {
2184
    /* Convert all the offsets into addresses.  */
2185
    int reg;
2186
    for (reg = 0; reg < gdbarch_num_regs (gdbarch); reg++)
2187
      {
2188
        if (trad_frame_addr_p (cache->saved_regs, reg))
2189
          cache->saved_regs[reg].addr += cache->base;
2190
      }
2191
  }
2192
 
2193
  {
2194
    struct gdbarch_tdep *tdep;
2195
 
2196
    tdep = gdbarch_tdep (gdbarch);
2197
 
2198
    if (tdep->unwind_adjust_stub)
2199
      {
2200
        tdep->unwind_adjust_stub (next_frame, cache->base, cache->saved_regs);
2201
      }
2202
  }
2203
 
2204
  if (hppa_debug)
2205
    fprintf_unfiltered (gdb_stdlog, "base=0x%s }",
2206
      paddr_nz (((struct hppa_frame_cache *)*this_cache)->base));
2207
  return (*this_cache);
2208
}
2209
 
2210
static void
2211
hppa_frame_this_id (struct frame_info *next_frame, void **this_cache,
2212
                           struct frame_id *this_id)
2213
{
2214
  struct hppa_frame_cache *info;
2215
  CORE_ADDR pc = frame_pc_unwind (next_frame);
2216
  struct unwind_table_entry *u;
2217
 
2218
  info = hppa_frame_cache (next_frame, this_cache);
2219
  u = hppa_find_unwind_entry_in_block (next_frame);
2220
 
2221
  (*this_id) = frame_id_build (info->base, u->region_start);
2222
}
2223
 
2224
static void
2225
hppa_frame_prev_register (struct frame_info *next_frame,
2226
                          void **this_cache,
2227
                          int regnum, int *optimizedp,
2228
                          enum lval_type *lvalp, CORE_ADDR *addrp,
2229
                          int *realnump, gdb_byte *valuep)
2230
{
2231
  struct hppa_frame_cache *info = hppa_frame_cache (next_frame, this_cache);
2232
  hppa_frame_prev_register_helper (next_frame, info->saved_regs, regnum,
2233
                                   optimizedp, lvalp, addrp, realnump, valuep);
2234
}
2235
 
2236
static const struct frame_unwind hppa_frame_unwind =
2237
{
2238
  NORMAL_FRAME,
2239
  hppa_frame_this_id,
2240
  hppa_frame_prev_register
2241
};
2242
 
2243
static const struct frame_unwind *
2244
hppa_frame_unwind_sniffer (struct frame_info *next_frame)
2245
{
2246
  if (hppa_find_unwind_entry_in_block (next_frame))
2247
    return &hppa_frame_unwind;
2248
 
2249
  return NULL;
2250
}
2251
 
2252
/* This is a generic fallback frame unwinder that kicks in if we fail all
2253
   the other ones.  Normally we would expect the stub and regular unwinder
2254
   to work, but in some cases we might hit a function that just doesn't
2255
   have any unwind information available.  In this case we try to do
2256
   unwinding solely based on code reading.  This is obviously going to be
2257
   slow, so only use this as a last resort.  Currently this will only
2258
   identify the stack and pc for the frame.  */
2259
 
2260
static struct hppa_frame_cache *
2261
hppa_fallback_frame_cache (struct frame_info *next_frame, void **this_cache)
2262
{
2263
  struct hppa_frame_cache *cache;
2264
  unsigned int frame_size = 0;
2265
  int found_rp = 0;
2266
  CORE_ADDR start_pc;
2267
 
2268
  if (hppa_debug)
2269
    fprintf_unfiltered (gdb_stdlog,
2270
                        "{ hppa_fallback_frame_cache (frame=%d) -> ",
2271
                        frame_relative_level (next_frame));
2272
 
2273
  cache = FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache);
2274
  (*this_cache) = cache;
2275
  cache->saved_regs = trad_frame_alloc_saved_regs (next_frame);
2276
 
2277
  start_pc = frame_func_unwind (next_frame, NORMAL_FRAME);
2278
  if (start_pc)
2279
    {
2280
      CORE_ADDR cur_pc = frame_pc_unwind (next_frame);
2281
      CORE_ADDR pc;
2282
 
2283
      for (pc = start_pc; pc < cur_pc; pc += 4)
2284
        {
2285
          unsigned int insn;
2286
 
2287
          insn = read_memory_unsigned_integer (pc, 4);
2288
          frame_size += prologue_inst_adjust_sp (insn);
2289
 
2290
          /* There are limited ways to store the return pointer into the
2291
             stack.  */
2292
          if (insn == 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
2293
            {
2294
              cache->saved_regs[HPPA_RP_REGNUM].addr = -20;
2295
              found_rp = 1;
2296
            }
2297
          else if (insn == 0x0fc212c1
2298
                   || insn == 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
2299
            {
2300
              cache->saved_regs[HPPA_RP_REGNUM].addr = -16;
2301
              found_rp = 1;
2302
            }
2303
        }
2304
    }
2305
 
2306
  if (hppa_debug)
2307
    fprintf_unfiltered (gdb_stdlog, " frame_size=%d, found_rp=%d }\n",
2308
                        frame_size, found_rp);
2309
 
2310
  cache->base = frame_unwind_register_unsigned (next_frame, HPPA_SP_REGNUM);
2311
  cache->base -= frame_size;
2312
  trad_frame_set_value (cache->saved_regs, HPPA_SP_REGNUM, cache->base);
2313
 
2314
  if (trad_frame_addr_p (cache->saved_regs, HPPA_RP_REGNUM))
2315
    {
2316
      cache->saved_regs[HPPA_RP_REGNUM].addr += cache->base;
2317
      cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] =
2318
        cache->saved_regs[HPPA_RP_REGNUM];
2319
    }
2320
  else
2321
    {
2322
      ULONGEST rp;
2323
      rp = frame_unwind_register_unsigned (next_frame, HPPA_RP_REGNUM);
2324
      trad_frame_set_value (cache->saved_regs, HPPA_PCOQ_HEAD_REGNUM, rp);
2325
    }
2326
 
2327
  return cache;
2328
}
2329
 
2330
static void
2331
hppa_fallback_frame_this_id (struct frame_info *next_frame, void **this_cache,
2332
                             struct frame_id *this_id)
2333
{
2334
  struct hppa_frame_cache *info =
2335
    hppa_fallback_frame_cache (next_frame, this_cache);
2336
  (*this_id) = frame_id_build (info->base,
2337
                               frame_func_unwind (next_frame, NORMAL_FRAME));
2338
}
2339
 
2340
static void
2341
hppa_fallback_frame_prev_register (struct frame_info *next_frame,
2342
                          void **this_cache,
2343
                          int regnum, int *optimizedp,
2344
                          enum lval_type *lvalp, CORE_ADDR *addrp,
2345
                          int *realnump, gdb_byte *valuep)
2346
{
2347
  struct hppa_frame_cache *info =
2348
    hppa_fallback_frame_cache (next_frame, this_cache);
2349
  hppa_frame_prev_register_helper (next_frame, info->saved_regs, regnum,
2350
                                   optimizedp, lvalp, addrp, realnump, valuep);
2351
}
2352
 
2353
static const struct frame_unwind hppa_fallback_frame_unwind =
2354
{
2355
  NORMAL_FRAME,
2356
  hppa_fallback_frame_this_id,
2357
  hppa_fallback_frame_prev_register
2358
};
2359
 
2360
static const struct frame_unwind *
2361
hppa_fallback_unwind_sniffer (struct frame_info *next_frame)
2362
{
2363
  return &hppa_fallback_frame_unwind;
2364
}
2365
 
2366
/* Stub frames, used for all kinds of call stubs.  */
2367
struct hppa_stub_unwind_cache
2368
{
2369
  CORE_ADDR base;
2370
  struct trad_frame_saved_reg *saved_regs;
2371
};
2372
 
2373
static struct hppa_stub_unwind_cache *
2374
hppa_stub_frame_unwind_cache (struct frame_info *next_frame,
2375
                              void **this_cache)
2376
{
2377
  struct gdbarch *gdbarch = get_frame_arch (next_frame);
2378
  struct hppa_stub_unwind_cache *info;
2379
  struct unwind_table_entry *u;
2380
 
2381
  if (*this_cache)
2382
    return *this_cache;
2383
 
2384
  info = FRAME_OBSTACK_ZALLOC (struct hppa_stub_unwind_cache);
2385
  *this_cache = info;
2386
  info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
2387
 
2388
  info->base = frame_unwind_register_unsigned (next_frame, HPPA_SP_REGNUM);
2389
 
2390
  if (gdbarch_osabi (gdbarch) == GDB_OSABI_HPUX_SOM)
2391
    {
2392
      /* HPUX uses export stubs in function calls; the export stub clobbers
2393
         the return value of the caller, and, later restores it from the
2394
         stack.  */
2395
      u = find_unwind_entry (frame_pc_unwind (next_frame));
2396
 
2397
      if (u && u->stub_unwind.stub_type == EXPORT)
2398
        {
2399
          info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].addr = info->base - 24;
2400
 
2401
          return info;
2402
        }
2403
    }
2404
 
2405
  /* By default we assume that stubs do not change the rp.  */
2406
  info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].realreg = HPPA_RP_REGNUM;
2407
 
2408
  return info;
2409
}
2410
 
2411
static void
2412
hppa_stub_frame_this_id (struct frame_info *next_frame,
2413
                         void **this_prologue_cache,
2414
                         struct frame_id *this_id)
2415
{
2416
  struct hppa_stub_unwind_cache *info
2417
    = hppa_stub_frame_unwind_cache (next_frame, this_prologue_cache);
2418
 
2419
  if (info)
2420
    *this_id = frame_id_build (info->base,
2421
                               frame_func_unwind (next_frame, NORMAL_FRAME));
2422
  else
2423
    *this_id = null_frame_id;
2424
}
2425
 
2426
static void
2427
hppa_stub_frame_prev_register (struct frame_info *next_frame,
2428
                               void **this_prologue_cache,
2429
                               int regnum, int *optimizedp,
2430
                               enum lval_type *lvalp, CORE_ADDR *addrp,
2431
                               int *realnump, gdb_byte *valuep)
2432
{
2433
  struct hppa_stub_unwind_cache *info
2434
    = hppa_stub_frame_unwind_cache (next_frame, this_prologue_cache);
2435
 
2436
  if (info)
2437
    hppa_frame_prev_register_helper (next_frame, info->saved_regs, regnum,
2438
                                     optimizedp, lvalp, addrp, realnump,
2439
                                     valuep);
2440
  else
2441
    error (_("Requesting registers from null frame."));
2442
}
2443
 
2444
static const struct frame_unwind hppa_stub_frame_unwind = {
2445
  NORMAL_FRAME,
2446
  hppa_stub_frame_this_id,
2447
  hppa_stub_frame_prev_register
2448
};
2449
 
2450
static const struct frame_unwind *
2451
hppa_stub_unwind_sniffer (struct frame_info *next_frame)
2452
{
2453
  CORE_ADDR pc = frame_unwind_address_in_block (next_frame, NORMAL_FRAME);
2454
  struct gdbarch *gdbarch = get_frame_arch (next_frame);
2455
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2456
 
2457
  if (pc == 0
2458
      || (tdep->in_solib_call_trampoline != NULL
2459
          && tdep->in_solib_call_trampoline (pc, NULL))
2460
      || gdbarch_in_solib_return_trampoline (gdbarch, pc, NULL))
2461
    return &hppa_stub_frame_unwind;
2462
  return NULL;
2463
}
2464
 
2465
static struct frame_id
2466
hppa_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
2467
{
2468
  return frame_id_build (frame_unwind_register_unsigned (next_frame,
2469
                                                         HPPA_SP_REGNUM),
2470
                         frame_pc_unwind (next_frame));
2471
}
2472
 
2473
CORE_ADDR
2474
hppa_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
2475
{
2476
  ULONGEST ipsw;
2477
  CORE_ADDR pc;
2478
 
2479
  ipsw = frame_unwind_register_unsigned (next_frame, HPPA_IPSW_REGNUM);
2480
  pc = frame_unwind_register_unsigned (next_frame, HPPA_PCOQ_HEAD_REGNUM);
2481
 
2482
  /* If the current instruction is nullified, then we are effectively
2483
     still executing the previous instruction.  Pretend we are still
2484
     there.  This is needed when single stepping; if the nullified
2485
     instruction is on a different line, we don't want GDB to think
2486
     we've stepped onto that line.  */
2487
  if (ipsw & 0x00200000)
2488
    pc -= 4;
2489
 
2490
  return pc & ~0x3;
2491
}
2492
 
2493
/* Return the minimal symbol whose name is NAME and stub type is STUB_TYPE.
2494
   Return NULL if no such symbol was found.  */
2495
 
2496
struct minimal_symbol *
2497
hppa_lookup_stub_minimal_symbol (const char *name,
2498
                                 enum unwind_stub_types stub_type)
2499
{
2500
  struct objfile *objfile;
2501
  struct minimal_symbol *msym;
2502
 
2503
  ALL_MSYMBOLS (objfile, msym)
2504
    {
2505
      if (strcmp (SYMBOL_LINKAGE_NAME (msym), name) == 0)
2506
        {
2507
          struct unwind_table_entry *u;
2508
 
2509
          u = find_unwind_entry (SYMBOL_VALUE (msym));
2510
          if (u != NULL && u->stub_unwind.stub_type == stub_type)
2511
            return msym;
2512
        }
2513
    }
2514
 
2515
  return NULL;
2516
}
2517
 
2518
static void
2519
unwind_command (char *exp, int from_tty)
2520
{
2521
  CORE_ADDR address;
2522
  struct unwind_table_entry *u;
2523
 
2524
  /* If we have an expression, evaluate it and use it as the address.  */
2525
 
2526
  if (exp != 0 && *exp != 0)
2527
    address = parse_and_eval_address (exp);
2528
  else
2529
    return;
2530
 
2531
  u = find_unwind_entry (address);
2532
 
2533
  if (!u)
2534
    {
2535
      printf_unfiltered ("Can't find unwind table entry for %s\n", exp);
2536
      return;
2537
    }
2538
 
2539
  printf_unfiltered ("unwind_table_entry (0x%lx):\n", (unsigned long)u);
2540
 
2541
  printf_unfiltered ("\tregion_start = ");
2542
  print_address (u->region_start, gdb_stdout);
2543
  gdb_flush (gdb_stdout);
2544
 
2545
  printf_unfiltered ("\n\tregion_end = ");
2546
  print_address (u->region_end, gdb_stdout);
2547
  gdb_flush (gdb_stdout);
2548
 
2549
#define pif(FLD) if (u->FLD) printf_unfiltered (" "#FLD);
2550
 
2551
  printf_unfiltered ("\n\tflags =");
2552
  pif (Cannot_unwind);
2553
  pif (Millicode);
2554
  pif (Millicode_save_sr0);
2555
  pif (Entry_SR);
2556
  pif (Args_stored);
2557
  pif (Variable_Frame);
2558
  pif (Separate_Package_Body);
2559
  pif (Frame_Extension_Millicode);
2560
  pif (Stack_Overflow_Check);
2561
  pif (Two_Instruction_SP_Increment);
2562
  pif (sr4export);
2563
  pif (cxx_info);
2564
  pif (cxx_try_catch);
2565
  pif (sched_entry_seq);
2566
  pif (Save_SP);
2567
  pif (Save_RP);
2568
  pif (Save_MRP_in_frame);
2569
  pif (save_r19);
2570
  pif (Cleanup_defined);
2571
  pif (MPE_XL_interrupt_marker);
2572
  pif (HP_UX_interrupt_marker);
2573
  pif (Large_frame);
2574
  pif (alloca_frame);
2575
 
2576
  putchar_unfiltered ('\n');
2577
 
2578
#define pin(FLD) printf_unfiltered ("\t"#FLD" = 0x%x\n", u->FLD);
2579
 
2580
  pin (Region_description);
2581
  pin (Entry_FR);
2582
  pin (Entry_GR);
2583
  pin (Total_frame_size);
2584
 
2585
  if (u->stub_unwind.stub_type)
2586
    {
2587
      printf_unfiltered ("\tstub type = ");
2588
      switch (u->stub_unwind.stub_type)
2589
        {
2590
          case LONG_BRANCH:
2591
            printf_unfiltered ("long branch\n");
2592
            break;
2593
          case PARAMETER_RELOCATION:
2594
            printf_unfiltered ("parameter relocation\n");
2595
            break;
2596
          case EXPORT:
2597
            printf_unfiltered ("export\n");
2598
            break;
2599
          case IMPORT:
2600
            printf_unfiltered ("import\n");
2601
            break;
2602
          case IMPORT_SHLIB:
2603
            printf_unfiltered ("import shlib\n");
2604
            break;
2605
          default:
2606
            printf_unfiltered ("unknown (%d)\n", u->stub_unwind.stub_type);
2607
        }
2608
    }
2609
}
2610
 
2611
/* Return the GDB type object for the "standard" data type of data in
2612
   register REGNUM.  */
2613
 
2614
static struct type *
2615
hppa32_register_type (struct gdbarch *gdbarch, int regnum)
2616
{
2617
   if (regnum < HPPA_FP4_REGNUM)
2618
     return builtin_type_uint32;
2619
   else
2620
     return builtin_type_ieee_single;
2621
}
2622
 
2623
static struct type *
2624
hppa64_register_type (struct gdbarch *gdbarch, int regnum)
2625
{
2626
   if (regnum < HPPA64_FP4_REGNUM)
2627
     return builtin_type_uint64;
2628
   else
2629
     return builtin_type_ieee_double;
2630
}
2631
 
2632
/* Return non-zero if REGNUM is not a register available to the user
2633
   through ptrace/ttrace.  */
2634
 
2635
static int
2636
hppa32_cannot_store_register (struct gdbarch *gdbarch, int regnum)
2637
{
2638
  return (regnum == 0
2639
          || regnum == HPPA_PCSQ_HEAD_REGNUM
2640
          || (regnum >= HPPA_PCSQ_TAIL_REGNUM && regnum < HPPA_IPSW_REGNUM)
2641
          || (regnum > HPPA_IPSW_REGNUM && regnum < HPPA_FP4_REGNUM));
2642
}
2643
 
2644
static int
2645
hppa32_cannot_fetch_register (struct gdbarch *gdbarch, int regnum)
2646
{
2647
  /* cr26 and cr27 are readable (but not writable) from userspace.  */
2648
  if (regnum == HPPA_CR26_REGNUM || regnum == HPPA_CR27_REGNUM)
2649
    return 0;
2650
  else
2651
    return hppa32_cannot_store_register (gdbarch, regnum);
2652
}
2653
 
2654
static int
2655
hppa64_cannot_store_register (struct gdbarch *gdbarch, int regnum)
2656
{
2657
  return (regnum == 0
2658
          || regnum == HPPA_PCSQ_HEAD_REGNUM
2659
          || (regnum >= HPPA_PCSQ_TAIL_REGNUM && regnum < HPPA_IPSW_REGNUM)
2660
          || (regnum > HPPA_IPSW_REGNUM && regnum < HPPA64_FP4_REGNUM));
2661
}
2662
 
2663
static int
2664
hppa64_cannot_fetch_register (struct gdbarch *gdbarch, int regnum)
2665
{
2666
  /* cr26 and cr27 are readable (but not writable) from userspace.  */
2667
  if (regnum == HPPA_CR26_REGNUM || regnum == HPPA_CR27_REGNUM)
2668
    return 0;
2669
  else
2670
    return hppa64_cannot_store_register (gdbarch, regnum);
2671
}
2672
 
2673
static CORE_ADDR
2674
hppa_smash_text_address (CORE_ADDR addr)
2675
{
2676
  /* The low two bits of the PC on the PA contain the privilege level.
2677
     Some genius implementing a (non-GCC) compiler apparently decided
2678
     this means that "addresses" in a text section therefore include a
2679
     privilege level, and thus symbol tables should contain these bits.
2680
     This seems like a bonehead thing to do--anyway, it seems to work
2681
     for our purposes to just ignore those bits.  */
2682
 
2683
  return (addr &= ~0x3);
2684
}
2685
 
2686
/* Get the ARGIth function argument for the current function.  */
2687
 
2688
static CORE_ADDR
2689
hppa_fetch_pointer_argument (struct frame_info *frame, int argi,
2690
                             struct type *type)
2691
{
2692
  return get_frame_register_unsigned (frame, HPPA_R0_REGNUM + 26 - argi);
2693
}
2694
 
2695
static void
2696
hppa_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
2697
                           int regnum, gdb_byte *buf)
2698
{
2699
    ULONGEST tmp;
2700
 
2701
    regcache_raw_read_unsigned (regcache, regnum, &tmp);
2702
    if (regnum == HPPA_PCOQ_HEAD_REGNUM || regnum == HPPA_PCOQ_TAIL_REGNUM)
2703
      tmp &= ~0x3;
2704
    store_unsigned_integer (buf, sizeof tmp, tmp);
2705
}
2706
 
2707
static CORE_ADDR
2708
hppa_find_global_pointer (struct gdbarch *gdbarch, struct value *function)
2709
{
2710
  return 0;
2711
}
2712
 
2713
void
2714
hppa_frame_prev_register_helper (struct frame_info *next_frame,
2715
                                 struct trad_frame_saved_reg saved_regs[],
2716
                                 int regnum, int *optimizedp,
2717
                                 enum lval_type *lvalp, CORE_ADDR *addrp,
2718
                                 int *realnump, gdb_byte *valuep)
2719
{
2720
  struct gdbarch *arch = get_frame_arch (next_frame);
2721
 
2722
  if (regnum == HPPA_PCOQ_TAIL_REGNUM)
2723
    {
2724
      if (valuep)
2725
        {
2726
          int size = register_size (arch, HPPA_PCOQ_HEAD_REGNUM);
2727
          CORE_ADDR pc;
2728
 
2729
          trad_frame_get_prev_register (next_frame, saved_regs,
2730
                                        HPPA_PCOQ_HEAD_REGNUM, optimizedp,
2731
                                        lvalp, addrp, realnump, valuep);
2732
 
2733
          pc = extract_unsigned_integer (valuep, size);
2734
          store_unsigned_integer (valuep, size, pc + 4);
2735
        }
2736
 
2737
      /* It's a computed value.  */
2738
      *optimizedp = 0;
2739
      *lvalp = not_lval;
2740
      *addrp = 0;
2741
      *realnump = -1;
2742
      return;
2743
    }
2744
 
2745
  /* Make sure the "flags" register is zero in all unwound frames.
2746
     The "flags" registers is a HP-UX specific wart, and only the code
2747
     in hppa-hpux-tdep.c depends on it.  However, it is easier to deal
2748
     with it here.  This shouldn't affect other systems since those
2749
     should provide zero for the "flags" register anyway.  */
2750
  if (regnum == HPPA_FLAGS_REGNUM)
2751
    {
2752
      if (valuep)
2753
        store_unsigned_integer (valuep, register_size (arch, regnum), 0);
2754
 
2755
      /* It's a computed value.  */
2756
      *optimizedp = 0;
2757
      *lvalp = not_lval;
2758
      *addrp = 0;
2759
      *realnump = -1;
2760
      return;
2761
    }
2762
 
2763
  trad_frame_get_prev_register (next_frame, saved_regs, regnum,
2764
                                optimizedp, lvalp, addrp, realnump, valuep);
2765
}
2766
 
2767
 
2768
/* An instruction to match.  */
2769
struct insn_pattern
2770
{
2771
  unsigned int data;            /* See if it matches this....  */
2772
  unsigned int mask;            /* ... with this mask.  */
2773
};
2774
 
2775
/* See bfd/elf32-hppa.c */
2776
static struct insn_pattern hppa_long_branch_stub[] = {
2777
  /* ldil LR'xxx,%r1 */
2778
  { 0x20200000, 0xffe00000 },
2779
  /* be,n RR'xxx(%sr4,%r1) */
2780
  { 0xe0202002, 0xffe02002 },
2781
  { 0, 0 }
2782
};
2783
 
2784
static struct insn_pattern hppa_long_branch_pic_stub[] = {
2785
  /* b,l .+8, %r1 */
2786
  { 0xe8200000, 0xffe00000 },
2787
  /* addil LR'xxx - ($PIC_pcrel$0 - 4), %r1 */
2788
  { 0x28200000, 0xffe00000 },
2789
  /* be,n RR'xxxx - ($PIC_pcrel$0 - 8)(%sr4, %r1) */
2790
  { 0xe0202002, 0xffe02002 },
2791
  { 0, 0 }
2792
};
2793
 
2794
static struct insn_pattern hppa_import_stub[] = {
2795
  /* addil LR'xxx, %dp */
2796
  { 0x2b600000, 0xffe00000 },
2797
  /* ldw RR'xxx(%r1), %r21 */
2798
  { 0x48350000, 0xffffb000 },
2799
  /* bv %r0(%r21) */
2800
  { 0xeaa0c000, 0xffffffff },
2801
  /* ldw RR'xxx+4(%r1), %r19 */
2802
  { 0x48330000, 0xffffb000 },
2803
  { 0, 0 }
2804
};
2805
 
2806
static struct insn_pattern hppa_import_pic_stub[] = {
2807
  /* addil LR'xxx,%r19 */
2808
  { 0x2a600000, 0xffe00000 },
2809
  /* ldw RR'xxx(%r1),%r21 */
2810
  { 0x48350000, 0xffffb000 },
2811
  /* bv %r0(%r21) */
2812
  { 0xeaa0c000, 0xffffffff },
2813
  /* ldw RR'xxx+4(%r1),%r19 */
2814
  { 0x48330000, 0xffffb000 },
2815
  { 0, 0 },
2816
};
2817
 
2818
static struct insn_pattern hppa_plt_stub[] = {
2819
  /* b,l 1b, %r20 - 1b is 3 insns before here */
2820
  { 0xea9f1fdd, 0xffffffff },
2821
  /* depi 0,31,2,%r20 */
2822
  { 0xd6801c1e, 0xffffffff },
2823
  { 0, 0 }
2824
};
2825
 
2826
static struct insn_pattern hppa_sigtramp[] = {
2827
  /* ldi 0, %r25 or ldi 1, %r25 */
2828
  { 0x34190000, 0xfffffffd },
2829
  /* ldi __NR_rt_sigreturn, %r20 */
2830
  { 0x3414015a, 0xffffffff },
2831
  /* be,l 0x100(%sr2, %r0), %sr0, %r31 */
2832
  { 0xe4008200, 0xffffffff },
2833
  /* nop */
2834
  { 0x08000240, 0xffffffff },
2835
  { 0, 0 }
2836
};
2837
 
2838
/* Maximum number of instructions on the patterns above.  */
2839
#define HPPA_MAX_INSN_PATTERN_LEN       4
2840
 
2841
/* Return non-zero if the instructions at PC match the series
2842
   described in PATTERN, or zero otherwise.  PATTERN is an array of
2843
   'struct insn_pattern' objects, terminated by an entry whose mask is
2844
   zero.
2845
 
2846
   When the match is successful, fill INSN[i] with what PATTERN[i]
2847
   matched.  */
2848
 
2849
static int
2850
hppa_match_insns (CORE_ADDR pc, struct insn_pattern *pattern,
2851
                  unsigned int *insn)
2852
{
2853
  CORE_ADDR npc = pc;
2854
  int i;
2855
 
2856
  for (i = 0; pattern[i].mask; i++)
2857
    {
2858
      gdb_byte buf[HPPA_INSN_SIZE];
2859
 
2860
      read_memory_nobpt (npc, buf, HPPA_INSN_SIZE);
2861
      insn[i] = extract_unsigned_integer (buf, HPPA_INSN_SIZE);
2862
      if ((insn[i] & pattern[i].mask) == pattern[i].data)
2863
        npc += 4;
2864
      else
2865
        return 0;
2866
    }
2867
 
2868
  return 1;
2869
}
2870
 
2871
/* This relaxed version of the insstruction matcher allows us to match
2872
   from somewhere inside the pattern, by looking backwards in the
2873
   instruction scheme.  */
2874
 
2875
static int
2876
hppa_match_insns_relaxed (CORE_ADDR pc, struct insn_pattern *pattern,
2877
                          unsigned int *insn)
2878
{
2879
  int offset, len = 0;
2880
 
2881
  while (pattern[len].mask)
2882
    len++;
2883
 
2884
  for (offset = 0; offset < len; offset++)
2885
    if (hppa_match_insns (pc - offset * HPPA_INSN_SIZE, pattern, insn))
2886
      return 1;
2887
 
2888
  return 0;
2889
}
2890
 
2891
static int
2892
hppa_in_dyncall (CORE_ADDR pc)
2893
{
2894
  struct unwind_table_entry *u;
2895
 
2896
  u = find_unwind_entry (hppa_symbol_address ("$$dyncall"));
2897
  if (!u)
2898
    return 0;
2899
 
2900
  return (pc >= u->region_start && pc <= u->region_end);
2901
}
2902
 
2903
int
2904
hppa_in_solib_call_trampoline (CORE_ADDR pc, char *name)
2905
{
2906
  unsigned int insn[HPPA_MAX_INSN_PATTERN_LEN];
2907
  struct unwind_table_entry *u;
2908
 
2909
  if (in_plt_section (pc, name) || hppa_in_dyncall (pc))
2910
    return 1;
2911
 
2912
  /* The GNU toolchain produces linker stubs without unwind
2913
     information.  Since the pattern matching for linker stubs can be
2914
     quite slow, so bail out if we do have an unwind entry.  */
2915
 
2916
  u = find_unwind_entry (pc);
2917
  if (u != NULL)
2918
    return 0;
2919
 
2920
  return (hppa_match_insns_relaxed (pc, hppa_import_stub, insn)
2921
          || hppa_match_insns_relaxed (pc, hppa_import_pic_stub, insn)
2922
          || hppa_match_insns_relaxed (pc, hppa_long_branch_stub, insn)
2923
          || hppa_match_insns_relaxed (pc, hppa_long_branch_pic_stub, insn));
2924
}
2925
 
2926
/* This code skips several kind of "trampolines" used on PA-RISC
2927
   systems: $$dyncall, import stubs and PLT stubs.  */
2928
 
2929
CORE_ADDR
2930
hppa_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
2931
{
2932
  unsigned int insn[HPPA_MAX_INSN_PATTERN_LEN];
2933
  int dp_rel;
2934
 
2935
  /* $$dyncall handles both PLABELs and direct addresses.  */
2936
  if (hppa_in_dyncall (pc))
2937
    {
2938
      pc = get_frame_register_unsigned (frame, HPPA_R0_REGNUM + 22);
2939
 
2940
      /* PLABELs have bit 30 set; if it's a PLABEL, then dereference it.  */
2941
      if (pc & 0x2)
2942
        pc = read_memory_typed_address (pc & ~0x3, builtin_type_void_func_ptr);
2943
 
2944
      return pc;
2945
    }
2946
 
2947
  dp_rel = hppa_match_insns (pc, hppa_import_stub, insn);
2948
  if (dp_rel || hppa_match_insns (pc, hppa_import_pic_stub, insn))
2949
    {
2950
      /* Extract the target address from the addil/ldw sequence.  */
2951
      pc = hppa_extract_21 (insn[0]) + hppa_extract_14 (insn[1]);
2952
 
2953
      if (dp_rel)
2954
        pc += get_frame_register_unsigned (frame, HPPA_DP_REGNUM);
2955
      else
2956
        pc += get_frame_register_unsigned (frame, HPPA_R0_REGNUM + 19);
2957
 
2958
      /* fallthrough */
2959
    }
2960
 
2961
  if (in_plt_section (pc, NULL))
2962
    {
2963
      pc = read_memory_typed_address (pc, builtin_type_void_func_ptr);
2964
 
2965
      /* If the PLT slot has not yet been resolved, the target will be
2966
         the PLT stub.  */
2967
      if (in_plt_section (pc, NULL))
2968
        {
2969
          /* Sanity check: are we pointing to the PLT stub?  */
2970
          if (!hppa_match_insns (pc, hppa_plt_stub, insn))
2971
            {
2972
              warning (_("Cannot resolve PLT stub at 0x%s."), paddr_nz (pc));
2973
              return 0;
2974
            }
2975
 
2976
          /* This should point to the fixup routine.  */
2977
          pc = read_memory_typed_address (pc + 8, builtin_type_void_func_ptr);
2978
        }
2979
    }
2980
 
2981
  return pc;
2982
}
2983
 
2984
 
2985
/* Here is a table of C type sizes on hppa with various compiles
2986
   and options.  I measured this on PA 9000/800 with HP-UX 11.11
2987
   and these compilers:
2988
 
2989
     /usr/ccs/bin/cc    HP92453-01 A.11.01.21
2990
     /opt/ansic/bin/cc  HP92453-01 B.11.11.28706.GP
2991
     /opt/aCC/bin/aCC   B3910B A.03.45
2992
     gcc                gcc 3.3.2 native hppa2.0w-hp-hpux11.11
2993
 
2994
     cc            : 1 2 4 4 8 : 4 8 -- : 4 4
2995
     ansic +DA1.1  : 1 2 4 4 8 : 4 8 16 : 4 4
2996
     ansic +DA2.0  : 1 2 4 4 8 : 4 8 16 : 4 4
2997
     ansic +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
2998
     acc   +DA1.1  : 1 2 4 4 8 : 4 8 16 : 4 4
2999
     acc   +DA2.0  : 1 2 4 4 8 : 4 8 16 : 4 4
3000
     acc   +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
3001
     gcc           : 1 2 4 4 8 : 4 8 16 : 4 4
3002
 
3003
   Each line is:
3004
 
3005
     compiler and options
3006
     char, short, int, long, long long
3007
     float, double, long double
3008
     char *, void (*)()
3009
 
3010
   So all these compilers use either ILP32 or LP64 model.
3011
   TODO: gcc has more options so it needs more investigation.
3012
 
3013
   For floating point types, see:
3014
 
3015
     http://docs.hp.com/hpux/pdf/B3906-90006.pdf
3016
     HP-UX floating-point guide, hpux 11.00
3017
 
3018
   -- chastain 2003-12-18  */
3019
 
3020
static struct gdbarch *
3021
hppa_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
3022
{
3023
  struct gdbarch_tdep *tdep;
3024
  struct gdbarch *gdbarch;
3025
 
3026
  /* Try to determine the ABI of the object we are loading.  */
3027
  if (info.abfd != NULL && info.osabi == GDB_OSABI_UNKNOWN)
3028
    {
3029
      /* If it's a SOM file, assume it's HP/UX SOM.  */
3030
      if (bfd_get_flavour (info.abfd) == bfd_target_som_flavour)
3031
        info.osabi = GDB_OSABI_HPUX_SOM;
3032
    }
3033
 
3034
  /* find a candidate among the list of pre-declared architectures.  */
3035
  arches = gdbarch_list_lookup_by_info (arches, &info);
3036
  if (arches != NULL)
3037
    return (arches->gdbarch);
3038
 
3039
  /* If none found, then allocate and initialize one.  */
3040
  tdep = XZALLOC (struct gdbarch_tdep);
3041
  gdbarch = gdbarch_alloc (&info, tdep);
3042
 
3043
  /* Determine from the bfd_arch_info structure if we are dealing with
3044
     a 32 or 64 bits architecture.  If the bfd_arch_info is not available,
3045
     then default to a 32bit machine.  */
3046
  if (info.bfd_arch_info != NULL)
3047
    tdep->bytes_per_address =
3048
      info.bfd_arch_info->bits_per_address / info.bfd_arch_info->bits_per_byte;
3049
  else
3050
    tdep->bytes_per_address = 4;
3051
 
3052
  tdep->find_global_pointer = hppa_find_global_pointer;
3053
 
3054
  /* Some parts of the gdbarch vector depend on whether we are running
3055
     on a 32 bits or 64 bits target.  */
3056
  switch (tdep->bytes_per_address)
3057
    {
3058
      case 4:
3059
        set_gdbarch_num_regs (gdbarch, hppa32_num_regs);
3060
        set_gdbarch_register_name (gdbarch, hppa32_register_name);
3061
        set_gdbarch_register_type (gdbarch, hppa32_register_type);
3062
        set_gdbarch_cannot_store_register (gdbarch,
3063
                                           hppa32_cannot_store_register);
3064
        set_gdbarch_cannot_fetch_register (gdbarch,
3065
                                           hppa32_cannot_fetch_register);
3066
        break;
3067
      case 8:
3068
        set_gdbarch_num_regs (gdbarch, hppa64_num_regs);
3069
        set_gdbarch_register_name (gdbarch, hppa64_register_name);
3070
        set_gdbarch_register_type (gdbarch, hppa64_register_type);
3071
        set_gdbarch_dwarf_reg_to_regnum (gdbarch, hppa64_dwarf_reg_to_regnum);
3072
        set_gdbarch_dwarf2_reg_to_regnum (gdbarch, hppa64_dwarf_reg_to_regnum);
3073
        set_gdbarch_cannot_store_register (gdbarch,
3074
                                           hppa64_cannot_store_register);
3075
        set_gdbarch_cannot_fetch_register (gdbarch,
3076
                                           hppa64_cannot_fetch_register);
3077
        break;
3078
      default:
3079
        internal_error (__FILE__, __LINE__, _("Unsupported address size: %d"),
3080
                        tdep->bytes_per_address);
3081
    }
3082
 
3083
  set_gdbarch_long_bit (gdbarch, tdep->bytes_per_address * TARGET_CHAR_BIT);
3084
  set_gdbarch_ptr_bit (gdbarch, tdep->bytes_per_address * TARGET_CHAR_BIT);
3085
 
3086
  /* The following gdbarch vector elements are the same in both ILP32
3087
     and LP64, but might show differences some day.  */
3088
  set_gdbarch_long_long_bit (gdbarch, 64);
3089
  set_gdbarch_long_double_bit (gdbarch, 128);
3090
  set_gdbarch_long_double_format (gdbarch, floatformats_ia64_quad);
3091
 
3092
  /* The following gdbarch vector elements do not depend on the address
3093
     size, or in any other gdbarch element previously set.  */
3094
  set_gdbarch_skip_prologue (gdbarch, hppa_skip_prologue);
3095
  set_gdbarch_in_function_epilogue_p (gdbarch,
3096
                                      hppa_in_function_epilogue_p);
3097
  set_gdbarch_inner_than (gdbarch, core_addr_greaterthan);
3098
  set_gdbarch_sp_regnum (gdbarch, HPPA_SP_REGNUM);
3099
  set_gdbarch_fp0_regnum (gdbarch, HPPA_FP0_REGNUM);
3100
  set_gdbarch_addr_bits_remove (gdbarch, hppa_smash_text_address);
3101
  set_gdbarch_smash_text_address (gdbarch, hppa_smash_text_address);
3102
  set_gdbarch_believe_pcc_promotion (gdbarch, 1);
3103
  set_gdbarch_read_pc (gdbarch, hppa_read_pc);
3104
  set_gdbarch_write_pc (gdbarch, hppa_write_pc);
3105
 
3106
  /* Helper for function argument information.  */
3107
  set_gdbarch_fetch_pointer_argument (gdbarch, hppa_fetch_pointer_argument);
3108
 
3109
  set_gdbarch_print_insn (gdbarch, print_insn_hppa);
3110
 
3111
  /* When a hardware watchpoint triggers, we'll move the inferior past
3112
     it by removing all eventpoints; stepping past the instruction
3113
     that caused the trigger; reinserting eventpoints; and checking
3114
     whether any watched location changed.  */
3115
  set_gdbarch_have_nonsteppable_watchpoint (gdbarch, 1);
3116
 
3117
  /* Inferior function call methods.  */
3118
  switch (tdep->bytes_per_address)
3119
    {
3120
    case 4:
3121
      set_gdbarch_push_dummy_call (gdbarch, hppa32_push_dummy_call);
3122
      set_gdbarch_frame_align (gdbarch, hppa32_frame_align);
3123
      set_gdbarch_convert_from_func_ptr_addr
3124
        (gdbarch, hppa32_convert_from_func_ptr_addr);
3125
      break;
3126
    case 8:
3127
      set_gdbarch_push_dummy_call (gdbarch, hppa64_push_dummy_call);
3128
      set_gdbarch_frame_align (gdbarch, hppa64_frame_align);
3129
      break;
3130
    default:
3131
      internal_error (__FILE__, __LINE__, _("bad switch"));
3132
    }
3133
 
3134
  /* Struct return methods.  */
3135
  switch (tdep->bytes_per_address)
3136
    {
3137
    case 4:
3138
      set_gdbarch_return_value (gdbarch, hppa32_return_value);
3139
      break;
3140
    case 8:
3141
      set_gdbarch_return_value (gdbarch, hppa64_return_value);
3142
      break;
3143
    default:
3144
      internal_error (__FILE__, __LINE__, _("bad switch"));
3145
    }
3146
 
3147
  set_gdbarch_breakpoint_from_pc (gdbarch, hppa_breakpoint_from_pc);
3148
  set_gdbarch_pseudo_register_read (gdbarch, hppa_pseudo_register_read);
3149
 
3150
  /* Frame unwind methods.  */
3151
  set_gdbarch_unwind_dummy_id (gdbarch, hppa_unwind_dummy_id);
3152
  set_gdbarch_unwind_pc (gdbarch, hppa_unwind_pc);
3153
 
3154
  /* Hook in ABI-specific overrides, if they have been registered.  */
3155
  gdbarch_init_osabi (info, gdbarch);
3156
 
3157
  /* Hook in the default unwinders.  */
3158
  frame_unwind_append_sniffer (gdbarch, hppa_stub_unwind_sniffer);
3159
  frame_unwind_append_sniffer (gdbarch, hppa_frame_unwind_sniffer);
3160
  frame_unwind_append_sniffer (gdbarch, hppa_fallback_unwind_sniffer);
3161
 
3162
  return gdbarch;
3163
}
3164
 
3165
static void
3166
hppa_dump_tdep (struct gdbarch *gdbarch, struct ui_file *file)
3167
{
3168
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3169
 
3170
  fprintf_unfiltered (file, "bytes_per_address = %d\n",
3171
                      tdep->bytes_per_address);
3172
  fprintf_unfiltered (file, "elf = %s\n", tdep->is_elf ? "yes" : "no");
3173
}
3174
 
3175
void
3176
_initialize_hppa_tdep (void)
3177
{
3178
  struct cmd_list_element *c;
3179
 
3180
  gdbarch_register (bfd_arch_hppa, hppa_gdbarch_init, hppa_dump_tdep);
3181
 
3182
  hppa_objfile_priv_data = register_objfile_data ();
3183
 
3184
  add_cmd ("unwind", class_maintenance, unwind_command,
3185
           _("Print unwind table entry at given address."),
3186
           &maintenanceprintlist);
3187
 
3188
  /* Debug this files internals. */
3189
  add_setshow_boolean_cmd ("hppa", class_maintenance, &hppa_debug, _("\
3190
Set whether hppa target specific debugging information should be displayed."),
3191
                           _("\
3192
Show whether hppa target specific debugging information is displayed."), _("\
3193
This flag controls whether hppa target specific debugging information is\n\
3194
displayed.  This information is particularly useful for debugging frame\n\
3195
unwinding problems."),
3196
                           NULL,
3197
                           NULL, /* FIXME: i18n: hppa debug flag is %s.  */
3198
                           &setdebuglist, &showdebuglist);
3199
}

powered by: WebSVN 2.1.0

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