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