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