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