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