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