1 /* Target-dependent code for the HP PA architecture, for GDB. 2 Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996 3 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 2 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, write to the Free Software 22 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 23 24 #include "defs.h" 25 #include "frame.h" 26 #include "inferior.h" 27 #include "value.h" 28 29 /* For argument passing to the inferior */ 30 #include "symtab.h" 31 32 #ifdef USG 33 #include <sys/types.h> 34 #endif 35 36 #include <sys/param.h> 37 #include <signal.h> 38 39 #ifdef COFF_ENCAPSULATE 40 #include "a.out.encap.h" 41 #else 42 #endif 43 #ifndef N_SET_MAGIC 44 #define N_SET_MAGIC(exec, val) ((exec).a_magic = (val)) 45 #endif 46 47 /*#include <sys/user.h> After a.out.h */ 48 #include <sys/file.h> 49 #include "gdb_stat.h" 50 #include "wait.h" 51 52 #include "gdbcore.h" 53 #include "gdbcmd.h" 54 #include "target.h" 55 #include "symfile.h" 56 #include "objfiles.h" 57 58 static int extract_5_load PARAMS ((unsigned int)); 59 60 static unsigned extract_5R_store PARAMS ((unsigned int)); 61 62 static unsigned extract_5r_store PARAMS ((unsigned int)); 63 64 static void find_dummy_frame_regs PARAMS ((struct frame_info *, 65 struct frame_saved_regs *)); 66 67 static int find_proc_framesize PARAMS ((CORE_ADDR)); 68 69 static int find_return_regnum PARAMS ((CORE_ADDR)); 70 71 struct unwind_table_entry *find_unwind_entry PARAMS ((CORE_ADDR)); 72 73 static int extract_17 PARAMS ((unsigned int)); 74 75 static unsigned deposit_21 PARAMS ((unsigned int, unsigned int)); 76 77 static int extract_21 PARAMS ((unsigned)); 78 79 static unsigned deposit_14 PARAMS ((int, unsigned int)); 80 81 static int extract_14 PARAMS ((unsigned)); 82 83 static void unwind_command PARAMS ((char *, int)); 84 85 static int low_sign_extend PARAMS ((unsigned int, unsigned int)); 86 87 static int sign_extend PARAMS ((unsigned int, unsigned int)); 88 89 static int restore_pc_queue PARAMS ((struct frame_saved_regs *)); 90 91 static int hppa_alignof PARAMS ((struct type *)); 92 93 static int prologue_inst_adjust_sp PARAMS ((unsigned long)); 94 95 static int is_branch PARAMS ((unsigned long)); 96 97 static int inst_saves_gr PARAMS ((unsigned long)); 98 99 static int inst_saves_fr PARAMS ((unsigned long)); 100 101 static int pc_in_interrupt_handler PARAMS ((CORE_ADDR)); 102 103 static int pc_in_linker_stub PARAMS ((CORE_ADDR)); 104 105 static int compare_unwind_entries PARAMS ((const void *, const void *)); 106 107 static void read_unwind_info PARAMS ((struct objfile *)); 108 109 static void internalize_unwinds PARAMS ((struct objfile *, 110 struct unwind_table_entry *, 111 asection *, unsigned int, 112 unsigned int, CORE_ADDR)); 113 static void pa_print_registers PARAMS ((char *, int, int)); 114 static void pa_print_fp_reg PARAMS ((int)); 115 116 117 /* Routines to extract various sized constants out of hppa 118 instructions. */ 119 120 /* This assumes that no garbage lies outside of the lower bits of 121 value. */ 122 123 static int 124 sign_extend (val, bits) 125 unsigned val, bits; 126 { 127 return (int)(val >> (bits - 1) ? (-1 << bits) | val : val); 128 } 129 130 /* For many immediate values the sign bit is the low bit! */ 131 132 static int 133 low_sign_extend (val, bits) 134 unsigned val, bits; 135 { 136 return (int)((val & 0x1 ? (-1 << (bits - 1)) : 0) | val >> 1); 137 } 138 139 /* extract the immediate field from a ld{bhw}s instruction */ 140 141 #if 0 142 143 unsigned 144 get_field (val, from, to) 145 unsigned val, from, to; 146 { 147 val = val >> 31 - to; 148 return val & ((1 << 32 - from) - 1); 149 } 150 151 unsigned 152 set_field (val, from, to, new_val) 153 unsigned *val, from, to; 154 { 155 unsigned mask = ~((1 << (to - from + 1)) << (31 - from)); 156 return *val = *val & mask | (new_val << (31 - from)); 157 } 158 159 /* extract a 3-bit space register number from a be, ble, mtsp or mfsp */ 160 161 int 162 extract_3 (word) 163 unsigned word; 164 { 165 return GET_FIELD (word, 18, 18) << 2 | GET_FIELD (word, 16, 17); 166 } 167 168 #endif 169 170 static int 171 extract_5_load (word) 172 unsigned word; 173 { 174 return low_sign_extend (word >> 16 & MASK_5, 5); 175 } 176 177 #if 0 178 179 /* extract the immediate field from a st{bhw}s instruction */ 180 181 int 182 extract_5_store (word) 183 unsigned word; 184 { 185 return low_sign_extend (word & MASK_5, 5); 186 } 187 188 #endif /* 0 */ 189 190 /* extract the immediate field from a break instruction */ 191 192 static unsigned 193 extract_5r_store (word) 194 unsigned word; 195 { 196 return (word & MASK_5); 197 } 198 199 /* extract the immediate field from a {sr}sm instruction */ 200 201 static unsigned 202 extract_5R_store (word) 203 unsigned word; 204 { 205 return (word >> 16 & MASK_5); 206 } 207 208 /* extract an 11 bit immediate field */ 209 210 #if 0 211 212 int 213 extract_11 (word) 214 unsigned word; 215 { 216 return low_sign_extend (word & MASK_11, 11); 217 } 218 219 #endif 220 221 /* extract a 14 bit immediate field */ 222 223 static int 224 extract_14 (word) 225 unsigned word; 226 { 227 return low_sign_extend (word & MASK_14, 14); 228 } 229 230 /* deposit a 14 bit constant in a word */ 231 232 static unsigned 233 deposit_14 (opnd, word) 234 int opnd; 235 unsigned word; 236 { 237 unsigned sign = (opnd < 0 ? 1 : 0); 238 239 return word | ((unsigned)opnd << 1 & MASK_14) | sign; 240 } 241 242 /* extract a 21 bit constant */ 243 244 static int 245 extract_21 (word) 246 unsigned word; 247 { 248 int val; 249 250 word &= MASK_21; 251 word <<= 11; 252 val = GET_FIELD (word, 20, 20); 253 val <<= 11; 254 val |= GET_FIELD (word, 9, 19); 255 val <<= 2; 256 val |= GET_FIELD (word, 5, 6); 257 val <<= 5; 258 val |= GET_FIELD (word, 0, 4); 259 val <<= 2; 260 val |= GET_FIELD (word, 7, 8); 261 return sign_extend (val, 21) << 11; 262 } 263 264 /* deposit a 21 bit constant in a word. Although 21 bit constants are 265 usually the top 21 bits of a 32 bit constant, we assume that only 266 the low 21 bits of opnd are relevant */ 267 268 static unsigned 269 deposit_21 (opnd, word) 270 unsigned opnd, word; 271 { 272 unsigned val = 0; 273 274 val |= GET_FIELD (opnd, 11 + 14, 11 + 18); 275 val <<= 2; 276 val |= GET_FIELD (opnd, 11 + 12, 11 + 13); 277 val <<= 2; 278 val |= GET_FIELD (opnd, 11 + 19, 11 + 20); 279 val <<= 11; 280 val |= GET_FIELD (opnd, 11 + 1, 11 + 11); 281 val <<= 1; 282 val |= GET_FIELD (opnd, 11 + 0, 11 + 0); 283 return word | val; 284 } 285 286 /* extract a 12 bit constant from branch instructions */ 287 288 #if 0 289 290 int 291 extract_12 (word) 292 unsigned word; 293 { 294 return sign_extend (GET_FIELD (word, 19, 28) | 295 GET_FIELD (word, 29, 29) << 10 | 296 (word & 0x1) << 11, 12) << 2; 297 } 298 299 /* Deposit a 17 bit constant in an instruction (like bl). */ 300 301 unsigned int 302 deposit_17 (opnd, word) 303 unsigned opnd, word; 304 { 305 word |= GET_FIELD (opnd, 15 + 0, 15 + 0); /* w */ 306 word |= GET_FIELD (opnd, 15 + 1, 15 + 5) << 16; /* w1 */ 307 word |= GET_FIELD (opnd, 15 + 6, 15 + 6) << 2; /* w2[10] */ 308 word |= GET_FIELD (opnd, 15 + 7, 15 + 16) << 3; /* w2[0..9] */ 309 310 return word; 311 } 312 313 #endif 314 315 /* extract a 17 bit constant from branch instructions, returning the 316 19 bit signed value. */ 317 318 static int 319 extract_17 (word) 320 unsigned word; 321 { 322 return sign_extend (GET_FIELD (word, 19, 28) | 323 GET_FIELD (word, 29, 29) << 10 | 324 GET_FIELD (word, 11, 15) << 11 | 325 (word & 0x1) << 16, 17) << 2; 326 } 327 328 329 /* Compare the start address for two unwind entries returning 1 if 330 the first address is larger than the second, -1 if the second is 331 larger than the first, and zero if they are equal. */ 332 333 static int 334 compare_unwind_entries (arg1, arg2) 335 const void *arg1; 336 const void *arg2; 337 { 338 const struct unwind_table_entry *a = arg1; 339 const struct unwind_table_entry *b = arg2; 340 341 if (a->region_start > b->region_start) 342 return 1; 343 else if (a->region_start < b->region_start) 344 return -1; 345 else 346 return 0; 347 } 348 349 static void 350 internalize_unwinds (objfile, table, section, entries, size, text_offset) 351 struct objfile *objfile; 352 struct unwind_table_entry *table; 353 asection *section; 354 unsigned int entries, size; 355 CORE_ADDR text_offset; 356 { 357 /* We will read the unwind entries into temporary memory, then 358 fill in the actual unwind table. */ 359 if (size > 0) 360 { 361 unsigned long tmp; 362 unsigned i; 363 char *buf = alloca (size); 364 365 bfd_get_section_contents (objfile->obfd, section, buf, 0, size); 366 367 /* Now internalize the information being careful to handle host/target 368 endian issues. */ 369 for (i = 0; i < entries; i++) 370 { 371 table[i].region_start = bfd_get_32 (objfile->obfd, 372 (bfd_byte *)buf); 373 table[i].region_start += text_offset; 374 buf += 4; 375 table[i].region_end = bfd_get_32 (objfile->obfd, (bfd_byte *)buf); 376 table[i].region_end += text_offset; 377 buf += 4; 378 tmp = bfd_get_32 (objfile->obfd, (bfd_byte *)buf); 379 buf += 4; 380 table[i].Cannot_unwind = (tmp >> 31) & 0x1; 381 table[i].Millicode = (tmp >> 30) & 0x1; 382 table[i].Millicode_save_sr0 = (tmp >> 29) & 0x1; 383 table[i].Region_description = (tmp >> 27) & 0x3; 384 table[i].reserved1 = (tmp >> 26) & 0x1; 385 table[i].Entry_SR = (tmp >> 25) & 0x1; 386 table[i].Entry_FR = (tmp >> 21) & 0xf; 387 table[i].Entry_GR = (tmp >> 16) & 0x1f; 388 table[i].Args_stored = (tmp >> 15) & 0x1; 389 table[i].Variable_Frame = (tmp >> 14) & 0x1; 390 table[i].Separate_Package_Body = (tmp >> 13) & 0x1; 391 table[i].Frame_Extension_Millicode = (tmp >> 12 ) & 0x1; 392 table[i].Stack_Overflow_Check = (tmp >> 11) & 0x1; 393 table[i].Two_Instruction_SP_Increment = (tmp >> 10) & 0x1; 394 table[i].Ada_Region = (tmp >> 9) & 0x1; 395 table[i].reserved2 = (tmp >> 5) & 0xf; 396 table[i].Save_SP = (tmp >> 4) & 0x1; 397 table[i].Save_RP = (tmp >> 3) & 0x1; 398 table[i].Save_MRP_in_frame = (tmp >> 2) & 0x1; 399 table[i].extn_ptr_defined = (tmp >> 1) & 0x1; 400 table[i].Cleanup_defined = tmp & 0x1; 401 tmp = bfd_get_32 (objfile->obfd, (bfd_byte *)buf); 402 buf += 4; 403 table[i].MPE_XL_interrupt_marker = (tmp >> 31) & 0x1; 404 table[i].HP_UX_interrupt_marker = (tmp >> 30) & 0x1; 405 table[i].Large_frame = (tmp >> 29) & 0x1; 406 table[i].reserved4 = (tmp >> 27) & 0x3; 407 table[i].Total_frame_size = tmp & 0x7ffffff; 408 } 409 } 410 } 411 412 /* Read in the backtrace information stored in the `$UNWIND_START$' section of 413 the object file. This info is used mainly by find_unwind_entry() to find 414 out the stack frame size and frame pointer used by procedures. We put 415 everything on the psymbol obstack in the objfile so that it automatically 416 gets freed when the objfile is destroyed. */ 417 418 static void 419 read_unwind_info (objfile) 420 struct objfile *objfile; 421 { 422 asection *unwind_sec, *elf_unwind_sec, *stub_unwind_sec; 423 unsigned unwind_size, elf_unwind_size, stub_unwind_size, total_size; 424 unsigned index, unwind_entries, elf_unwind_entries; 425 unsigned stub_entries, total_entries; 426 CORE_ADDR text_offset; 427 struct obj_unwind_info *ui; 428 429 text_offset = ANOFFSET (objfile->section_offsets, 0); 430 ui = (struct obj_unwind_info *)obstack_alloc (&objfile->psymbol_obstack, 431 sizeof (struct obj_unwind_info)); 432 433 ui->table = NULL; 434 ui->cache = NULL; 435 ui->last = -1; 436 437 /* Get hooks to all unwind sections. Note there is no linker-stub unwind 438 section in ELF at the moment. */ 439 unwind_sec = bfd_get_section_by_name (objfile->obfd, "$UNWIND_START$"); 440 elf_unwind_sec = bfd_get_section_by_name (objfile->obfd, ".PARISC.unwind"); 441 stub_unwind_sec = bfd_get_section_by_name (objfile->obfd, "$UNWIND_END$"); 442 443 /* Get sizes and unwind counts for all sections. */ 444 if (unwind_sec) 445 { 446 unwind_size = bfd_section_size (objfile->obfd, unwind_sec); 447 unwind_entries = unwind_size / UNWIND_ENTRY_SIZE; 448 } 449 else 450 { 451 unwind_size = 0; 452 unwind_entries = 0; 453 } 454 455 if (elf_unwind_sec) 456 { 457 elf_unwind_size = bfd_section_size (objfile->obfd, elf_unwind_sec); 458 elf_unwind_entries = elf_unwind_size / UNWIND_ENTRY_SIZE; 459 } 460 else 461 { 462 elf_unwind_size = 0; 463 elf_unwind_entries = 0; 464 } 465 466 if (stub_unwind_sec) 467 { 468 stub_unwind_size = bfd_section_size (objfile->obfd, stub_unwind_sec); 469 stub_entries = stub_unwind_size / STUB_UNWIND_ENTRY_SIZE; 470 } 471 else 472 { 473 stub_unwind_size = 0; 474 stub_entries = 0; 475 } 476 477 /* Compute total number of unwind entries and their total size. */ 478 total_entries = unwind_entries + elf_unwind_entries + stub_entries; 479 total_size = total_entries * sizeof (struct unwind_table_entry); 480 481 /* Allocate memory for the unwind table. */ 482 ui->table = obstack_alloc (&objfile->psymbol_obstack, total_size); 483 ui->last = total_entries - 1; 484 485 /* Internalize the standard unwind entries. */ 486 index = 0; 487 internalize_unwinds (objfile, &ui->table[index], unwind_sec, 488 unwind_entries, unwind_size, text_offset); 489 index += unwind_entries; 490 internalize_unwinds (objfile, &ui->table[index], elf_unwind_sec, 491 elf_unwind_entries, elf_unwind_size, text_offset); 492 index += elf_unwind_entries; 493 494 /* Now internalize the stub unwind entries. */ 495 if (stub_unwind_size > 0) 496 { 497 unsigned int i; 498 char *buf = alloca (stub_unwind_size); 499 500 /* Read in the stub unwind entries. */ 501 bfd_get_section_contents (objfile->obfd, stub_unwind_sec, buf, 502 0, stub_unwind_size); 503 504 /* Now convert them into regular unwind entries. */ 505 for (i = 0; i < stub_entries; i++, index++) 506 { 507 /* Clear out the next unwind entry. */ 508 memset (&ui->table[index], 0, sizeof (struct unwind_table_entry)); 509 510 /* Convert offset & size into region_start and region_end. 511 Stuff away the stub type into "reserved" fields. */ 512 ui->table[index].region_start = bfd_get_32 (objfile->obfd, 513 (bfd_byte *) buf); 514 ui->table[index].region_start += text_offset; 515 buf += 4; 516 ui->table[index].stub_type = bfd_get_8 (objfile->obfd, 517 (bfd_byte *) buf); 518 buf += 2; 519 ui->table[index].region_end 520 = ui->table[index].region_start + 4 * 521 (bfd_get_16 (objfile->obfd, (bfd_byte *) buf) - 1); 522 buf += 2; 523 } 524 525 } 526 527 /* Unwind table needs to be kept sorted. */ 528 qsort (ui->table, total_entries, sizeof (struct unwind_table_entry), 529 compare_unwind_entries); 530 531 /* Keep a pointer to the unwind information. */ 532 objfile->obj_private = (PTR) ui; 533 } 534 535 /* Lookup the unwind (stack backtrace) info for the given PC. We search all 536 of the objfiles seeking the unwind table entry for this PC. Each objfile 537 contains a sorted list of struct unwind_table_entry. Since we do a binary 538 search of the unwind tables, we depend upon them to be sorted. */ 539 540 struct unwind_table_entry * 541 find_unwind_entry(pc) 542 CORE_ADDR pc; 543 { 544 int first, middle, last; 545 struct objfile *objfile; 546 547 ALL_OBJFILES (objfile) 548 { 549 struct obj_unwind_info *ui; 550 551 ui = OBJ_UNWIND_INFO (objfile); 552 553 if (!ui) 554 { 555 read_unwind_info (objfile); 556 ui = OBJ_UNWIND_INFO (objfile); 557 } 558 559 /* First, check the cache */ 560 561 if (ui->cache 562 && pc >= ui->cache->region_start 563 && pc <= ui->cache->region_end) 564 return ui->cache; 565 566 /* Not in the cache, do a binary search */ 567 568 first = 0; 569 last = ui->last; 570 571 while (first <= last) 572 { 573 middle = (first + last) / 2; 574 if (pc >= ui->table[middle].region_start 575 && pc <= ui->table[middle].region_end) 576 { 577 ui->cache = &ui->table[middle]; 578 return &ui->table[middle]; 579 } 580 581 if (pc < ui->table[middle].region_start) 582 last = middle - 1; 583 else 584 first = middle + 1; 585 } 586 } /* ALL_OBJFILES() */ 587 return NULL; 588 } 589 590 /* Return the adjustment necessary to make for addresses on the stack 591 as presented by hpread.c. 592 593 This is necessary because of the stack direction on the PA and the 594 bizarre way in which someone (?) decided they wanted to handle 595 frame pointerless code in GDB. */ 596 int 597 hpread_adjust_stack_address (func_addr) 598 CORE_ADDR func_addr; 599 { 600 struct unwind_table_entry *u; 601 602 u = find_unwind_entry (func_addr); 603 if (!u) 604 return 0; 605 else 606 return u->Total_frame_size << 3; 607 } 608 609 /* Called to determine if PC is in an interrupt handler of some 610 kind. */ 611 612 static int 613 pc_in_interrupt_handler (pc) 614 CORE_ADDR pc; 615 { 616 struct unwind_table_entry *u; 617 struct minimal_symbol *msym_us; 618 619 u = find_unwind_entry (pc); 620 if (!u) 621 return 0; 622 623 /* Oh joys. HPUX sets the interrupt bit for _sigreturn even though 624 its frame isn't a pure interrupt frame. Deal with this. */ 625 msym_us = lookup_minimal_symbol_by_pc (pc); 626 627 return u->HP_UX_interrupt_marker && !IN_SIGTRAMP (pc, SYMBOL_NAME (msym_us)); 628 } 629 630 /* Called when no unwind descriptor was found for PC. Returns 1 if it 631 appears that PC is in a linker stub. */ 632 633 static int 634 pc_in_linker_stub (pc) 635 CORE_ADDR pc; 636 { 637 int found_magic_instruction = 0; 638 int i; 639 char buf[4]; 640 641 /* If unable to read memory, assume pc is not in a linker stub. */ 642 if (target_read_memory (pc, buf, 4) != 0) 643 return 0; 644 645 /* We are looking for something like 646 647 ; $$dyncall jams RP into this special spot in the frame (RP') 648 ; before calling the "call stub" 649 ldw -18(sp),rp 650 651 ldsid (rp),r1 ; Get space associated with RP into r1 652 mtsp r1,sp ; Move it into space register 0 653 be,n 0(sr0),rp) ; back to your regularly scheduled program 654 */ 655 656 /* Maximum known linker stub size is 4 instructions. Search forward 657 from the given PC, then backward. */ 658 for (i = 0; i < 4; i++) 659 { 660 /* If we hit something with an unwind, stop searching this direction. */ 661 662 if (find_unwind_entry (pc + i * 4) != 0) 663 break; 664 665 /* Check for ldsid (rp),r1 which is the magic instruction for a 666 return from a cross-space function call. */ 667 if (read_memory_integer (pc + i * 4, 4) == 0x004010a1) 668 { 669 found_magic_instruction = 1; 670 break; 671 } 672 /* Add code to handle long call/branch and argument relocation stubs 673 here. */ 674 } 675 676 if (found_magic_instruction != 0) 677 return 1; 678 679 /* Now look backward. */ 680 for (i = 0; i < 4; i++) 681 { 682 /* If we hit something with an unwind, stop searching this direction. */ 683 684 if (find_unwind_entry (pc - i * 4) != 0) 685 break; 686 687 /* Check for ldsid (rp),r1 which is the magic instruction for a 688 return from a cross-space function call. */ 689 if (read_memory_integer (pc - i * 4, 4) == 0x004010a1) 690 { 691 found_magic_instruction = 1; 692 break; 693 } 694 /* Add code to handle long call/branch and argument relocation stubs 695 here. */ 696 } 697 return found_magic_instruction; 698 } 699 700 static int 701 find_return_regnum(pc) 702 CORE_ADDR pc; 703 { 704 struct unwind_table_entry *u; 705 706 u = find_unwind_entry (pc); 707 708 if (!u) 709 return RP_REGNUM; 710 711 if (u->Millicode) 712 return 31; 713 714 return RP_REGNUM; 715 } 716 717 /* Return size of frame, or -1 if we should use a frame pointer. */ 718 static int 719 find_proc_framesize (pc) 720 CORE_ADDR pc; 721 { 722 struct unwind_table_entry *u; 723 struct minimal_symbol *msym_us; 724 725 u = find_unwind_entry (pc); 726 727 if (!u) 728 { 729 if (pc_in_linker_stub (pc)) 730 /* Linker stubs have a zero size frame. */ 731 return 0; 732 else 733 return -1; 734 } 735 736 msym_us = lookup_minimal_symbol_by_pc (pc); 737 738 /* If Save_SP is set, and we're not in an interrupt or signal caller, 739 then we have a frame pointer. Use it. */ 740 if (u->Save_SP && !pc_in_interrupt_handler (pc) 741 && !IN_SIGTRAMP (pc, SYMBOL_NAME (msym_us))) 742 return -1; 743 744 return u->Total_frame_size << 3; 745 } 746 747 /* Return offset from sp at which rp is saved, or 0 if not saved. */ 748 static int rp_saved PARAMS ((CORE_ADDR)); 749 750 static int 751 rp_saved (pc) 752 CORE_ADDR pc; 753 { 754 struct unwind_table_entry *u; 755 756 u = find_unwind_entry (pc); 757 758 if (!u) 759 { 760 if (pc_in_linker_stub (pc)) 761 /* This is the so-called RP'. */ 762 return -24; 763 else 764 return 0; 765 } 766 767 if (u->Save_RP) 768 return -20; 769 else if (u->stub_type != 0) 770 { 771 switch (u->stub_type) 772 { 773 case EXPORT: 774 case IMPORT: 775 return -24; 776 case PARAMETER_RELOCATION: 777 return -8; 778 default: 779 return 0; 780 } 781 } 782 else 783 return 0; 784 } 785 786 int 787 frameless_function_invocation (frame) 788 struct frame_info *frame; 789 { 790 struct unwind_table_entry *u; 791 792 u = find_unwind_entry (frame->pc); 793 794 if (u == 0) 795 return 0; 796 797 return (u->Total_frame_size == 0 && u->stub_type == 0); 798 } 799 800 CORE_ADDR 801 saved_pc_after_call (frame) 802 struct frame_info *frame; 803 { 804 int ret_regnum; 805 CORE_ADDR pc; 806 struct unwind_table_entry *u; 807 808 ret_regnum = find_return_regnum (get_frame_pc (frame)); 809 pc = read_register (ret_regnum) & ~0x3; 810 811 /* If PC is in a linker stub, then we need to dig the address 812 the stub will return to out of the stack. */ 813 u = find_unwind_entry (pc); 814 if (u && u->stub_type != 0) 815 return FRAME_SAVED_PC (frame); 816 else 817 return pc; 818 } 819 820 CORE_ADDR 821 hppa_frame_saved_pc (frame) 822 struct frame_info *frame; 823 { 824 CORE_ADDR pc = get_frame_pc (frame); 825 struct unwind_table_entry *u; 826 827 /* BSD, HPUX & OSF1 all lay out the hardware state in the same manner 828 at the base of the frame in an interrupt handler. Registers within 829 are saved in the exact same order as GDB numbers registers. How 830 convienent. */ 831 if (pc_in_interrupt_handler (pc)) 832 return read_memory_integer (frame->frame + PC_REGNUM * 4, 4) & ~0x3; 833 834 #ifdef FRAME_SAVED_PC_IN_SIGTRAMP 835 /* Deal with signal handler caller frames too. */ 836 if (frame->signal_handler_caller) 837 { 838 CORE_ADDR rp; 839 FRAME_SAVED_PC_IN_SIGTRAMP (frame, &rp); 840 return rp & ~0x3; 841 } 842 #endif 843 844 if (frameless_function_invocation (frame)) 845 { 846 int ret_regnum; 847 848 ret_regnum = find_return_regnum (pc); 849 850 /* If the next frame is an interrupt frame or a signal 851 handler caller, then we need to look in the saved 852 register area to get the return pointer (the values 853 in the registers may not correspond to anything useful). */ 854 if (frame->next 855 && (frame->next->signal_handler_caller 856 || pc_in_interrupt_handler (frame->next->pc))) 857 { 858 struct frame_saved_regs saved_regs; 859 860 get_frame_saved_regs (frame->next, &saved_regs); 861 if (read_memory_integer (saved_regs.regs[FLAGS_REGNUM], 4) & 0x2) 862 { 863 pc = read_memory_integer (saved_regs.regs[31], 4) & ~0x3; 864 865 /* Syscalls are really two frames. The syscall stub itself 866 with a return pointer in %rp and the kernel call with 867 a return pointer in %r31. We return the %rp variant 868 if %r31 is the same as frame->pc. */ 869 if (pc == frame->pc) 870 pc = read_memory_integer (saved_regs.regs[RP_REGNUM], 4) & ~0x3; 871 } 872 else 873 pc = read_memory_integer (saved_regs.regs[RP_REGNUM], 4) & ~0x3; 874 } 875 else 876 pc = read_register (ret_regnum) & ~0x3; 877 } 878 else 879 { 880 int rp_offset; 881 882 restart: 883 rp_offset = rp_saved (pc); 884 /* Similar to code in frameless function case. If the next 885 frame is a signal or interrupt handler, then dig the right 886 information out of the saved register info. */ 887 if (rp_offset == 0 888 && frame->next 889 && (frame->next->signal_handler_caller 890 || pc_in_interrupt_handler (frame->next->pc))) 891 { 892 struct frame_saved_regs saved_regs; 893 894 get_frame_saved_regs (frame->next, &saved_regs); 895 if (read_memory_integer (saved_regs.regs[FLAGS_REGNUM], 4) & 0x2) 896 { 897 pc = read_memory_integer (saved_regs.regs[31], 4) & ~0x3; 898 899 /* Syscalls are really two frames. The syscall stub itself 900 with a return pointer in %rp and the kernel call with 901 a return pointer in %r31. We return the %rp variant 902 if %r31 is the same as frame->pc. */ 903 if (pc == frame->pc) 904 pc = read_memory_integer (saved_regs.regs[RP_REGNUM], 4) & ~0x3; 905 } 906 else 907 pc = read_memory_integer (saved_regs.regs[RP_REGNUM], 4) & ~0x3; 908 } 909 else if (rp_offset == 0) 910 pc = read_register (RP_REGNUM) & ~0x3; 911 else 912 pc = read_memory_integer (frame->frame + rp_offset, 4) & ~0x3; 913 } 914 915 /* If PC is inside a linker stub, then dig out the address the stub 916 will return to. 917 918 Don't do this for long branch stubs. Why? For some unknown reason 919 _start is marked as a long branch stub in hpux10. */ 920 u = find_unwind_entry (pc); 921 if (u && u->stub_type != 0 922 && u->stub_type != LONG_BRANCH) 923 { 924 unsigned int insn; 925 926 /* If this is a dynamic executable, and we're in a signal handler, 927 then the call chain will eventually point us into the stub for 928 _sigreturn. Unlike most cases, we'll be pointed to the branch 929 to the real sigreturn rather than the code after the real branch!. 930 931 Else, try to dig the address the stub will return to in the normal 932 fashion. */ 933 insn = read_memory_integer (pc, 4); 934 if ((insn & 0xfc00e000) == 0xe8000000) 935 return (pc + extract_17 (insn) + 8) & ~0x3; 936 else 937 goto restart; 938 } 939 940 return pc; 941 } 942 943 /* We need to correct the PC and the FP for the outermost frame when we are 944 in a system call. */ 945 946 void 947 init_extra_frame_info (fromleaf, frame) 948 int fromleaf; 949 struct frame_info *frame; 950 { 951 int flags; 952 int framesize; 953 954 if (frame->next && !fromleaf) 955 return; 956 957 /* If the next frame represents a frameless function invocation 958 then we have to do some adjustments that are normally done by 959 FRAME_CHAIN. (FRAME_CHAIN is not called in this case.) */ 960 if (fromleaf) 961 { 962 /* Find the framesize of *this* frame without peeking at the PC 963 in the current frame structure (it isn't set yet). */ 964 framesize = find_proc_framesize (FRAME_SAVED_PC (get_next_frame (frame))); 965 966 /* Now adjust our base frame accordingly. If we have a frame pointer 967 use it, else subtract the size of this frame from the current 968 frame. (we always want frame->frame to point at the lowest address 969 in the frame). */ 970 if (framesize == -1) 971 frame->frame = read_register (FP_REGNUM); 972 else 973 frame->frame -= framesize; 974 return; 975 } 976 977 flags = read_register (FLAGS_REGNUM); 978 if (flags & 2) /* In system call? */ 979 frame->pc = read_register (31) & ~0x3; 980 981 /* The outermost frame is always derived from PC-framesize 982 983 One might think frameless innermost frames should have 984 a frame->frame that is the same as the parent's frame->frame. 985 That is wrong; frame->frame in that case should be the *high* 986 address of the parent's frame. It's complicated as hell to 987 explain, but the parent *always* creates some stack space for 988 the child. So the child actually does have a frame of some 989 sorts, and its base is the high address in its parent's frame. */ 990 framesize = find_proc_framesize(frame->pc); 991 if (framesize == -1) 992 frame->frame = read_register (FP_REGNUM); 993 else 994 frame->frame = read_register (SP_REGNUM) - framesize; 995 } 996 997 /* Given a GDB frame, determine the address of the calling function's frame. 998 This will be used to create a new GDB frame struct, and then 999 INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame. 1000 1001 This may involve searching through prologues for several functions 1002 at boundaries where GCC calls HP C code, or where code which has 1003 a frame pointer calls code without a frame pointer. */ 1004 1005 CORE_ADDR 1006 frame_chain (frame) 1007 struct frame_info *frame; 1008 { 1009 int my_framesize, caller_framesize; 1010 struct unwind_table_entry *u; 1011 CORE_ADDR frame_base; 1012 struct frame_info *tmp_frame; 1013 1014 /* Handle HPUX, BSD, and OSF1 style interrupt frames first. These 1015 are easy; at *sp we have a full save state strucutre which we can 1016 pull the old stack pointer from. Also see frame_saved_pc for 1017 code to dig a saved PC out of the save state structure. */ 1018 if (pc_in_interrupt_handler (frame->pc)) 1019 frame_base = read_memory_integer (frame->frame + SP_REGNUM * 4, 4); 1020 #ifdef FRAME_BASE_BEFORE_SIGTRAMP 1021 else if (frame->signal_handler_caller) 1022 { 1023 FRAME_BASE_BEFORE_SIGTRAMP (frame, &frame_base); 1024 } 1025 #endif 1026 else 1027 frame_base = frame->frame; 1028 1029 /* Get frame sizes for the current frame and the frame of the 1030 caller. */ 1031 my_framesize = find_proc_framesize (frame->pc); 1032 caller_framesize = find_proc_framesize (FRAME_SAVED_PC(frame)); 1033 1034 /* If caller does not have a frame pointer, then its frame 1035 can be found at current_frame - caller_framesize. */ 1036 if (caller_framesize != -1) 1037 return frame_base - caller_framesize; 1038 1039 /* Both caller and callee have frame pointers and are GCC compiled 1040 (SAVE_SP bit in unwind descriptor is on for both functions. 1041 The previous frame pointer is found at the top of the current frame. */ 1042 if (caller_framesize == -1 && my_framesize == -1) 1043 return read_memory_integer (frame_base, 4); 1044 1045 /* Caller has a frame pointer, but callee does not. This is a little 1046 more difficult as GCC and HP C lay out locals and callee register save 1047 areas very differently. 1048 1049 The previous frame pointer could be in a register, or in one of 1050 several areas on the stack. 1051 1052 Walk from the current frame to the innermost frame examining 1053 unwind descriptors to determine if %r3 ever gets saved into the 1054 stack. If so return whatever value got saved into the stack. 1055 If it was never saved in the stack, then the value in %r3 is still 1056 valid, so use it. 1057 1058 We use information from unwind descriptors to determine if %r3 1059 is saved into the stack (Entry_GR field has this information). */ 1060 1061 tmp_frame = frame; 1062 while (tmp_frame) 1063 { 1064 u = find_unwind_entry (tmp_frame->pc); 1065 1066 if (!u) 1067 { 1068 /* We could find this information by examining prologues. I don't 1069 think anyone has actually written any tools (not even "strip") 1070 which leave them out of an executable, so maybe this is a moot 1071 point. */ 1072 warning ("Unable to find unwind for PC 0x%x -- Help!", tmp_frame->pc); 1073 return 0; 1074 } 1075 1076 /* Entry_GR specifies the number of callee-saved general registers 1077 saved in the stack. It starts at %r3, so %r3 would be 1. */ 1078 if (u->Entry_GR >= 1 || u->Save_SP 1079 || tmp_frame->signal_handler_caller 1080 || pc_in_interrupt_handler (tmp_frame->pc)) 1081 break; 1082 else 1083 tmp_frame = tmp_frame->next; 1084 } 1085 1086 if (tmp_frame) 1087 { 1088 /* We may have walked down the chain into a function with a frame 1089 pointer. */ 1090 if (u->Save_SP 1091 && !tmp_frame->signal_handler_caller 1092 && !pc_in_interrupt_handler (tmp_frame->pc)) 1093 return read_memory_integer (tmp_frame->frame, 4); 1094 /* %r3 was saved somewhere in the stack. Dig it out. */ 1095 else 1096 { 1097 struct frame_saved_regs saved_regs; 1098 1099 /* Sick. 1100 1101 For optimization purposes many kernels don't have the 1102 callee saved registers into the save_state structure upon 1103 entry into the kernel for a syscall; the optimization 1104 is usually turned off if the process is being traced so 1105 that the debugger can get full register state for the 1106 process. 1107 1108 This scheme works well except for two cases: 1109 1110 * Attaching to a process when the process is in the 1111 kernel performing a system call (debugger can't get 1112 full register state for the inferior process since 1113 the process wasn't being traced when it entered the 1114 system call). 1115 1116 * Register state is not complete if the system call 1117 causes the process to core dump. 1118 1119 1120 The following heinous code is an attempt to deal with 1121 the lack of register state in a core dump. It will 1122 fail miserably if the function which performs the 1123 system call has a variable sized stack frame. */ 1124 1125 get_frame_saved_regs (tmp_frame, &saved_regs); 1126 1127 /* Abominable hack. */ 1128 if (current_target.to_has_execution == 0 1129 && ((saved_regs.regs[FLAGS_REGNUM] 1130 && (read_memory_integer (saved_regs.regs[FLAGS_REGNUM], 4) 1131 & 0x2)) 1132 || (saved_regs.regs[FLAGS_REGNUM] == 0 1133 && read_register (FLAGS_REGNUM) & 0x2))) 1134 { 1135 u = find_unwind_entry (FRAME_SAVED_PC (frame)); 1136 if (!u) 1137 return read_memory_integer (saved_regs.regs[FP_REGNUM], 4); 1138 else 1139 return frame_base - (u->Total_frame_size << 3); 1140 } 1141 1142 return read_memory_integer (saved_regs.regs[FP_REGNUM], 4); 1143 } 1144 } 1145 else 1146 { 1147 struct frame_saved_regs saved_regs; 1148 1149 /* Get the innermost frame. */ 1150 tmp_frame = frame; 1151 while (tmp_frame->next != NULL) 1152 tmp_frame = tmp_frame->next; 1153 1154 get_frame_saved_regs (tmp_frame, &saved_regs); 1155 /* Abominable hack. See above. */ 1156 if (current_target.to_has_execution == 0 1157 && ((saved_regs.regs[FLAGS_REGNUM] 1158 && (read_memory_integer (saved_regs.regs[FLAGS_REGNUM], 4) 1159 & 0x2)) 1160 || (saved_regs.regs[FLAGS_REGNUM] == 0 1161 && read_register (FLAGS_REGNUM) & 0x2))) 1162 { 1163 u = find_unwind_entry (FRAME_SAVED_PC (frame)); 1164 if (!u) 1165 return read_memory_integer (saved_regs.regs[FP_REGNUM], 4); 1166 else 1167 return frame_base - (u->Total_frame_size << 3); 1168 } 1169 1170 /* The value in %r3 was never saved into the stack (thus %r3 still 1171 holds the value of the previous frame pointer). */ 1172 return read_register (FP_REGNUM); 1173 } 1174 } 1175 1176 1177 /* To see if a frame chain is valid, see if the caller looks like it 1178 was compiled with gcc. */ 1179 1180 int 1181 frame_chain_valid (chain, thisframe) 1182 CORE_ADDR chain; 1183 struct frame_info *thisframe; 1184 { 1185 struct minimal_symbol *msym_us; 1186 struct minimal_symbol *msym_start; 1187 struct unwind_table_entry *u, *next_u = NULL; 1188 struct frame_info *next; 1189 1190 if (!chain) 1191 return 0; 1192 1193 u = find_unwind_entry (thisframe->pc); 1194 1195 if (u == NULL) 1196 return 1; 1197 1198 /* We can't just check that the same of msym_us is "_start", because 1199 someone idiotically decided that they were going to make a Ltext_end 1200 symbol with the same address. This Ltext_end symbol is totally 1201 indistinguishable (as nearly as I can tell) from the symbol for a function 1202 which is (legitimately, since it is in the user's namespace) 1203 named Ltext_end, so we can't just ignore it. */ 1204 msym_us = lookup_minimal_symbol_by_pc (FRAME_SAVED_PC (thisframe)); 1205 msym_start = lookup_minimal_symbol ("_start", NULL, NULL); 1206 if (msym_us 1207 && msym_start 1208 && SYMBOL_VALUE_ADDRESS (msym_us) == SYMBOL_VALUE_ADDRESS (msym_start)) 1209 return 0; 1210 1211 /* Grrrr. Some new idiot decided that they don't want _start for the 1212 PRO configurations; $START$ calls main directly.... Deal with it. */ 1213 msym_start = lookup_minimal_symbol ("$START$", NULL, NULL); 1214 if (msym_us 1215 && msym_start 1216 && SYMBOL_VALUE_ADDRESS (msym_us) == SYMBOL_VALUE_ADDRESS (msym_start)) 1217 return 0; 1218 1219 next = get_next_frame (thisframe); 1220 if (next) 1221 next_u = find_unwind_entry (next->pc); 1222 1223 /* If this frame does not save SP, has no stack, isn't a stub, 1224 and doesn't "call" an interrupt routine or signal handler caller, 1225 then its not valid. */ 1226 if (u->Save_SP || u->Total_frame_size || u->stub_type != 0 1227 || (thisframe->next && thisframe->next->signal_handler_caller) 1228 || (next_u && next_u->HP_UX_interrupt_marker)) 1229 return 1; 1230 1231 if (pc_in_linker_stub (thisframe->pc)) 1232 return 1; 1233 1234 return 0; 1235 } 1236 1237 /* 1238 * These functions deal with saving and restoring register state 1239 * around a function call in the inferior. They keep the stack 1240 * double-word aligned; eventually, on an hp700, the stack will have 1241 * to be aligned to a 64-byte boundary. 1242 */ 1243 1244 void 1245 push_dummy_frame (inf_status) 1246 struct inferior_status *inf_status; 1247 { 1248 CORE_ADDR sp, pc, pcspace; 1249 register int regnum; 1250 int int_buffer; 1251 double freg_buffer; 1252 1253 /* Oh, what a hack. If we're trying to perform an inferior call 1254 while the inferior is asleep, we have to make sure to clear 1255 the "in system call" bit in the flag register (the call will 1256 start after the syscall returns, so we're no longer in the system 1257 call!) This state is kept in "inf_status", change it there. 1258 1259 We also need a number of horrid hacks to deal with lossage in the 1260 PC queue registers (apparently they're not valid when the in syscall 1261 bit is set). */ 1262 pc = target_read_pc (inferior_pid); 1263 int_buffer = read_register (FLAGS_REGNUM); 1264 if (int_buffer & 0x2) 1265 { 1266 unsigned int sid; 1267 int_buffer &= ~0x2; 1268 memcpy (inf_status->registers, &int_buffer, 4); 1269 memcpy (inf_status->registers + REGISTER_BYTE (PCOQ_HEAD_REGNUM), &pc, 4); 1270 pc += 4; 1271 memcpy (inf_status->registers + REGISTER_BYTE (PCOQ_TAIL_REGNUM), &pc, 4); 1272 pc -= 4; 1273 sid = (pc >> 30) & 0x3; 1274 if (sid == 0) 1275 pcspace = read_register (SR4_REGNUM); 1276 else 1277 pcspace = read_register (SR4_REGNUM + 4 + sid); 1278 memcpy (inf_status->registers + REGISTER_BYTE (PCSQ_HEAD_REGNUM), 1279 &pcspace, 4); 1280 memcpy (inf_status->registers + REGISTER_BYTE (PCSQ_TAIL_REGNUM), 1281 &pcspace, 4); 1282 } 1283 else 1284 pcspace = read_register (PCSQ_HEAD_REGNUM); 1285 1286 /* Space for "arguments"; the RP goes in here. */ 1287 sp = read_register (SP_REGNUM) + 48; 1288 int_buffer = read_register (RP_REGNUM) | 0x3; 1289 write_memory (sp - 20, (char *)&int_buffer, 4); 1290 1291 int_buffer = read_register (FP_REGNUM); 1292 write_memory (sp, (char *)&int_buffer, 4); 1293 1294 write_register (FP_REGNUM, sp); 1295 1296 sp += 8; 1297 1298 for (regnum = 1; regnum < 32; regnum++) 1299 if (regnum != RP_REGNUM && regnum != FP_REGNUM) 1300 sp = push_word (sp, read_register (regnum)); 1301 1302 sp += 4; 1303 1304 for (regnum = FP0_REGNUM; regnum < NUM_REGS; regnum++) 1305 { 1306 read_register_bytes (REGISTER_BYTE (regnum), (char *)&freg_buffer, 8); 1307 sp = push_bytes (sp, (char *)&freg_buffer, 8); 1308 } 1309 sp = push_word (sp, read_register (IPSW_REGNUM)); 1310 sp = push_word (sp, read_register (SAR_REGNUM)); 1311 sp = push_word (sp, pc); 1312 sp = push_word (sp, pcspace); 1313 sp = push_word (sp, pc + 4); 1314 sp = push_word (sp, pcspace); 1315 write_register (SP_REGNUM, sp); 1316 } 1317 1318 static void 1319 find_dummy_frame_regs (frame, frame_saved_regs) 1320 struct frame_info *frame; 1321 struct frame_saved_regs *frame_saved_regs; 1322 { 1323 CORE_ADDR fp = frame->frame; 1324 int i; 1325 1326 frame_saved_regs->regs[RP_REGNUM] = (fp - 20) & ~0x3; 1327 frame_saved_regs->regs[FP_REGNUM] = fp; 1328 frame_saved_regs->regs[1] = fp + 8; 1329 1330 for (fp += 12, i = 3; i < 32; i++) 1331 { 1332 if (i != FP_REGNUM) 1333 { 1334 frame_saved_regs->regs[i] = fp; 1335 fp += 4; 1336 } 1337 } 1338 1339 fp += 4; 1340 for (i = FP0_REGNUM; i < NUM_REGS; i++, fp += 8) 1341 frame_saved_regs->regs[i] = fp; 1342 1343 frame_saved_regs->regs[IPSW_REGNUM] = fp; 1344 frame_saved_regs->regs[SAR_REGNUM] = fp + 4; 1345 frame_saved_regs->regs[PCOQ_HEAD_REGNUM] = fp + 8; 1346 frame_saved_regs->regs[PCSQ_HEAD_REGNUM] = fp + 12; 1347 frame_saved_regs->regs[PCOQ_TAIL_REGNUM] = fp + 16; 1348 frame_saved_regs->regs[PCSQ_TAIL_REGNUM] = fp + 20; 1349 } 1350 1351 void 1352 hppa_pop_frame () 1353 { 1354 register struct frame_info *frame = get_current_frame (); 1355 register CORE_ADDR fp, npc, target_pc; 1356 register int regnum; 1357 struct frame_saved_regs fsr; 1358 double freg_buffer; 1359 1360 fp = FRAME_FP (frame); 1361 get_frame_saved_regs (frame, &fsr); 1362 1363 #ifndef NO_PC_SPACE_QUEUE_RESTORE 1364 if (fsr.regs[IPSW_REGNUM]) /* Restoring a call dummy frame */ 1365 restore_pc_queue (&fsr); 1366 #endif 1367 1368 for (regnum = 31; regnum > 0; regnum--) 1369 if (fsr.regs[regnum]) 1370 write_register (regnum, read_memory_integer (fsr.regs[regnum], 4)); 1371 1372 for (regnum = NUM_REGS - 1; regnum >= FP0_REGNUM ; regnum--) 1373 if (fsr.regs[regnum]) 1374 { 1375 read_memory (fsr.regs[regnum], (char *)&freg_buffer, 8); 1376 write_register_bytes (REGISTER_BYTE (regnum), (char *)&freg_buffer, 8); 1377 } 1378 1379 if (fsr.regs[IPSW_REGNUM]) 1380 write_register (IPSW_REGNUM, 1381 read_memory_integer (fsr.regs[IPSW_REGNUM], 4)); 1382 1383 if (fsr.regs[SAR_REGNUM]) 1384 write_register (SAR_REGNUM, 1385 read_memory_integer (fsr.regs[SAR_REGNUM], 4)); 1386 1387 /* If the PC was explicitly saved, then just restore it. */ 1388 if (fsr.regs[PCOQ_TAIL_REGNUM]) 1389 { 1390 npc = read_memory_integer (fsr.regs[PCOQ_TAIL_REGNUM], 4); 1391 write_register (PCOQ_TAIL_REGNUM, npc); 1392 } 1393 /* Else use the value in %rp to set the new PC. */ 1394 else 1395 { 1396 npc = read_register (RP_REGNUM); 1397 write_pc (npc); 1398 } 1399 1400 write_register (FP_REGNUM, read_memory_integer (fp, 4)); 1401 1402 if (fsr.regs[IPSW_REGNUM]) /* call dummy */ 1403 write_register (SP_REGNUM, fp - 48); 1404 else 1405 write_register (SP_REGNUM, fp); 1406 1407 /* The PC we just restored may be inside a return trampoline. If so 1408 we want to restart the inferior and run it through the trampoline. 1409 1410 Do this by setting a momentary breakpoint at the location the 1411 trampoline returns to. 1412 1413 Don't skip through the trampoline if we're popping a dummy frame. */ 1414 target_pc = SKIP_TRAMPOLINE_CODE (npc & ~0x3) & ~0x3; 1415 if (target_pc && !fsr.regs[IPSW_REGNUM]) 1416 { 1417 struct symtab_and_line sal; 1418 struct breakpoint *breakpoint; 1419 struct cleanup *old_chain; 1420 1421 /* Set up our breakpoint. Set it to be silent as the MI code 1422 for "return_command" will print the frame we returned to. */ 1423 sal = find_pc_line (target_pc, 0); 1424 sal.pc = target_pc; 1425 breakpoint = set_momentary_breakpoint (sal, NULL, bp_finish); 1426 breakpoint->silent = 1; 1427 1428 /* So we can clean things up. */ 1429 old_chain = make_cleanup (delete_breakpoint, breakpoint); 1430 1431 /* Start up the inferior. */ 1432 clear_proceed_status (); 1433 proceed_to_finish = 1; 1434 proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0); 1435 1436 /* Perform our cleanups. */ 1437 do_cleanups (old_chain); 1438 } 1439 flush_cached_frames (); 1440 } 1441 1442 /* 1443 * After returning to a dummy on the stack, restore the instruction 1444 * queue space registers. */ 1445 1446 static int 1447 restore_pc_queue (fsr) 1448 struct frame_saved_regs *fsr; 1449 { 1450 CORE_ADDR pc = read_pc (); 1451 CORE_ADDR new_pc = read_memory_integer (fsr->regs[PCOQ_HEAD_REGNUM], 4); 1452 struct target_waitstatus w; 1453 int insn_count; 1454 1455 /* Advance past break instruction in the call dummy. */ 1456 write_register (PCOQ_HEAD_REGNUM, pc + 4); 1457 write_register (PCOQ_TAIL_REGNUM, pc + 8); 1458 1459 /* 1460 * HPUX doesn't let us set the space registers or the space 1461 * registers of the PC queue through ptrace. Boo, hiss. 1462 * Conveniently, the call dummy has this sequence of instructions 1463 * after the break: 1464 * mtsp r21, sr0 1465 * ble,n 0(sr0, r22) 1466 * 1467 * So, load up the registers and single step until we are in the 1468 * right place. 1469 */ 1470 1471 write_register (21, read_memory_integer (fsr->regs[PCSQ_HEAD_REGNUM], 4)); 1472 write_register (22, new_pc); 1473 1474 for (insn_count = 0; insn_count < 3; insn_count++) 1475 { 1476 /* FIXME: What if the inferior gets a signal right now? Want to 1477 merge this into wait_for_inferior (as a special kind of 1478 watchpoint? By setting a breakpoint at the end? Is there 1479 any other choice? Is there *any* way to do this stuff with 1480 ptrace() or some equivalent?). */ 1481 resume (1, 0); 1482 target_wait (inferior_pid, &w); 1483 1484 if (w.kind == TARGET_WAITKIND_SIGNALLED) 1485 { 1486 stop_signal = w.value.sig; 1487 terminal_ours_for_output (); 1488 printf_unfiltered ("\nProgram terminated with signal %s, %s.\n", 1489 target_signal_to_name (stop_signal), 1490 target_signal_to_string (stop_signal)); 1491 gdb_flush (gdb_stdout); 1492 return 0; 1493 } 1494 } 1495 target_terminal_ours (); 1496 target_fetch_registers (-1); 1497 return 1; 1498 } 1499 1500 CORE_ADDR 1501 hppa_push_arguments (nargs, args, sp, struct_return, struct_addr) 1502 int nargs; 1503 value_ptr *args; 1504 CORE_ADDR sp; 1505 int struct_return; 1506 CORE_ADDR struct_addr; 1507 { 1508 /* array of arguments' offsets */ 1509 int *offset = (int *)alloca(nargs * sizeof (int)); 1510 int cum = 0; 1511 int i, alignment; 1512 1513 for (i = 0; i < nargs; i++) 1514 { 1515 cum += TYPE_LENGTH (VALUE_TYPE (args[i])); 1516 1517 /* value must go at proper alignment. Assume alignment is a 1518 power of two.*/ 1519 alignment = hppa_alignof (VALUE_TYPE (args[i])); 1520 if (cum % alignment) 1521 cum = (cum + alignment) & -alignment; 1522 offset[i] = -cum; 1523 } 1524 sp += max ((cum + 7) & -8, 16); 1525 1526 for (i = 0; i < nargs; i++) 1527 write_memory (sp + offset[i], VALUE_CONTENTS (args[i]), 1528 TYPE_LENGTH (VALUE_TYPE (args[i]))); 1529 1530 if (struct_return) 1531 write_register (28, struct_addr); 1532 return sp + 32; 1533 } 1534 1535 /* 1536 * Insert the specified number of args and function address 1537 * into a call sequence of the above form stored at DUMMYNAME. 1538 * 1539 * On the hppa we need to call the stack dummy through $$dyncall. 1540 * Therefore our version of FIX_CALL_DUMMY takes an extra argument, 1541 * real_pc, which is the location where gdb should start up the 1542 * inferior to do the function call. 1543 */ 1544 1545 CORE_ADDR 1546 hppa_fix_call_dummy (dummy, pc, fun, nargs, args, type, gcc_p) 1547 char *dummy; 1548 CORE_ADDR pc; 1549 CORE_ADDR fun; 1550 int nargs; 1551 value_ptr *args; 1552 struct type *type; 1553 int gcc_p; 1554 { 1555 CORE_ADDR dyncall_addr; 1556 struct minimal_symbol *msymbol; 1557 struct minimal_symbol *trampoline; 1558 int flags = read_register (FLAGS_REGNUM); 1559 struct unwind_table_entry *u; 1560 1561 trampoline = NULL; 1562 msymbol = lookup_minimal_symbol ("$$dyncall", NULL, NULL); 1563 if (msymbol == NULL) 1564 error ("Can't find an address for $$dyncall trampoline"); 1565 1566 dyncall_addr = SYMBOL_VALUE_ADDRESS (msymbol); 1567 1568 /* FUN could be a procedure label, in which case we have to get 1569 its real address and the value of its GOT/DP. */ 1570 if (fun & 0x2) 1571 { 1572 /* Get the GOT/DP value for the target function. It's 1573 at *(fun+4). Note the call dummy is *NOT* allowed to 1574 trash %r19 before calling the target function. */ 1575 write_register (19, read_memory_integer ((fun & ~0x3) + 4, 4)); 1576 1577 /* Now get the real address for the function we are calling, it's 1578 at *fun. */ 1579 fun = (CORE_ADDR) read_memory_integer (fun & ~0x3, 4); 1580 } 1581 else 1582 { 1583 1584 #ifndef GDB_TARGET_IS_PA_ELF 1585 /* FUN could be either an export stub, or the real address of a 1586 function in a shared library. We must call an import stub 1587 rather than the export stub or real function for lazy binding 1588 to work correctly. */ 1589 if (som_solib_get_got_by_pc (fun)) 1590 { 1591 struct objfile *objfile; 1592 struct minimal_symbol *funsymbol, *stub_symbol; 1593 CORE_ADDR newfun = 0; 1594 1595 funsymbol = lookup_minimal_symbol_by_pc (fun); 1596 if (!funsymbol) 1597 error ("Unable to find minimal symbol for target fucntion.\n"); 1598 1599 /* Search all the object files for an import symbol with the 1600 right name. */ 1601 ALL_OBJFILES (objfile) 1602 { 1603 stub_symbol = lookup_minimal_symbol (SYMBOL_NAME (funsymbol), 1604 NULL, objfile); 1605 /* Found a symbol with the right name. */ 1606 if (stub_symbol) 1607 { 1608 struct unwind_table_entry *u; 1609 /* It must be a shared library trampoline. */ 1610 if (MSYMBOL_TYPE (stub_symbol) != mst_solib_trampoline) 1611 continue; 1612 1613 /* It must also be an import stub. */ 1614 u = find_unwind_entry (SYMBOL_VALUE (stub_symbol)); 1615 if (!u || u->stub_type != IMPORT) 1616 continue; 1617 1618 /* OK. Looks like the correct import stub. */ 1619 newfun = SYMBOL_VALUE (stub_symbol); 1620 fun = newfun; 1621 } 1622 } 1623 if (newfun == 0) 1624 write_register (19, som_solib_get_got_by_pc (fun)); 1625 } 1626 #endif 1627 } 1628 1629 /* If we are calling an import stub (eg calling into a dynamic library) 1630 then have sr4export call the magic __d_plt_call routine which is linked 1631 in from end.o. (You can't use _sr4export to call the import stub as 1632 the value in sp-24 will get fried and you end up returning to the 1633 wrong location. You can't call the import stub directly as the code 1634 to bind the PLT entry to a function can't return to a stack address.) */ 1635 u = find_unwind_entry (fun); 1636 if (u && u->stub_type == IMPORT) 1637 { 1638 CORE_ADDR new_fun; 1639 1640 /* Prefer __gcc_plt_call over the HP supplied routine because 1641 __gcc_plt_call works for any number of arguments. */ 1642 trampoline = lookup_minimal_symbol ("__gcc_plt_call", NULL, NULL); 1643 if (trampoline == NULL) 1644 trampoline = lookup_minimal_symbol ("__d_plt_call", NULL, NULL); 1645 1646 if (trampoline == NULL) 1647 error ("Can't find an address for __d_plt_call or __gcc_plt_call trampoline"); 1648 1649 /* This is where sr4export will jump to. */ 1650 new_fun = SYMBOL_VALUE_ADDRESS (trampoline); 1651 1652 if (strcmp (SYMBOL_NAME (trampoline), "__d_plt_call") == 0) 1653 { 1654 /* We have to store the address of the stub in __shlib_funcptr. */ 1655 msymbol = lookup_minimal_symbol ("__shlib_funcptr", NULL, 1656 (struct objfile *)NULL); 1657 if (msymbol == NULL) 1658 error ("Can't find an address for __shlib_funcptr"); 1659 1660 target_write_memory (SYMBOL_VALUE_ADDRESS (msymbol), (char *)&fun, 4); 1661 1662 /* We want sr4export to call __d_plt_call, so we claim it is 1663 the final target. Clear trampoline. */ 1664 fun = new_fun; 1665 trampoline = NULL; 1666 } 1667 } 1668 1669 /* Store upper 21 bits of function address into ldil. fun will either be 1670 the final target (most cases) or __d_plt_call when calling into a shared 1671 library and __gcc_plt_call is not available. */ 1672 store_unsigned_integer 1673 (&dummy[FUNC_LDIL_OFFSET], 1674 INSTRUCTION_SIZE, 1675 deposit_21 (fun >> 11, 1676 extract_unsigned_integer (&dummy[FUNC_LDIL_OFFSET], 1677 INSTRUCTION_SIZE))); 1678 1679 /* Store lower 11 bits of function address into ldo */ 1680 store_unsigned_integer 1681 (&dummy[FUNC_LDO_OFFSET], 1682 INSTRUCTION_SIZE, 1683 deposit_14 (fun & MASK_11, 1684 extract_unsigned_integer (&dummy[FUNC_LDO_OFFSET], 1685 INSTRUCTION_SIZE))); 1686 #ifdef SR4EXPORT_LDIL_OFFSET 1687 1688 { 1689 CORE_ADDR trampoline_addr; 1690 1691 /* We may still need sr4export's address too. */ 1692 1693 if (trampoline == NULL) 1694 { 1695 msymbol = lookup_minimal_symbol ("_sr4export", NULL, NULL); 1696 if (msymbol == NULL) 1697 error ("Can't find an address for _sr4export trampoline"); 1698 1699 trampoline_addr = SYMBOL_VALUE_ADDRESS (msymbol); 1700 } 1701 else 1702 trampoline_addr = SYMBOL_VALUE_ADDRESS (trampoline); 1703 1704 1705 /* Store upper 21 bits of trampoline's address into ldil */ 1706 store_unsigned_integer 1707 (&dummy[SR4EXPORT_LDIL_OFFSET], 1708 INSTRUCTION_SIZE, 1709 deposit_21 (trampoline_addr >> 11, 1710 extract_unsigned_integer (&dummy[SR4EXPORT_LDIL_OFFSET], 1711 INSTRUCTION_SIZE))); 1712 1713 /* Store lower 11 bits of trampoline's address into ldo */ 1714 store_unsigned_integer 1715 (&dummy[SR4EXPORT_LDO_OFFSET], 1716 INSTRUCTION_SIZE, 1717 deposit_14 (trampoline_addr & MASK_11, 1718 extract_unsigned_integer (&dummy[SR4EXPORT_LDO_OFFSET], 1719 INSTRUCTION_SIZE))); 1720 } 1721 #endif 1722 1723 write_register (22, pc); 1724 1725 /* If we are in a syscall, then we should call the stack dummy 1726 directly. $$dyncall is not needed as the kernel sets up the 1727 space id registers properly based on the value in %r31. In 1728 fact calling $$dyncall will not work because the value in %r22 1729 will be clobbered on the syscall exit path. 1730 1731 Similarly if the current PC is in a shared library. Note however, 1732 this scheme won't work if the shared library isn't mapped into 1733 the same space as the stack. */ 1734 if (flags & 2) 1735 return pc; 1736 #ifndef GDB_TARGET_IS_PA_ELF 1737 else if (som_solib_get_got_by_pc (target_read_pc (inferior_pid))) 1738 return pc; 1739 #endif 1740 else 1741 return dyncall_addr; 1742 1743 } 1744 1745 /* Get the PC from %r31 if currently in a syscall. Also mask out privilege 1746 bits. */ 1747 1748 CORE_ADDR 1749 target_read_pc (pid) 1750 int pid; 1751 { 1752 int flags = read_register_pid (FLAGS_REGNUM, pid); 1753 1754 /* The following test does not belong here. It is OS-specific, and belongs 1755 in native code. */ 1756 /* Test SS_INSYSCALL */ 1757 if (flags & 2) 1758 return read_register_pid (31, pid) & ~0x3; 1759 1760 return read_register_pid (PC_REGNUM, pid) & ~0x3; 1761 } 1762 1763 /* Write out the PC. If currently in a syscall, then also write the new 1764 PC value into %r31. */ 1765 1766 void 1767 target_write_pc (v, pid) 1768 CORE_ADDR v; 1769 int pid; 1770 { 1771 int flags = read_register_pid (FLAGS_REGNUM, pid); 1772 1773 /* The following test does not belong here. It is OS-specific, and belongs 1774 in native code. */ 1775 /* If in a syscall, then set %r31. Also make sure to get the 1776 privilege bits set correctly. */ 1777 /* Test SS_INSYSCALL */ 1778 if (flags & 2) 1779 write_register_pid (31, v | 0x3, pid); 1780 1781 write_register_pid (PC_REGNUM, v, pid); 1782 write_register_pid (NPC_REGNUM, v + 4, pid); 1783 } 1784 1785 /* return the alignment of a type in bytes. Structures have the maximum 1786 alignment required by their fields. */ 1787 1788 static int 1789 hppa_alignof (type) 1790 struct type *type; 1791 { 1792 int max_align, align, i; 1793 CHECK_TYPEDEF (type); 1794 switch (TYPE_CODE (type)) 1795 { 1796 case TYPE_CODE_PTR: 1797 case TYPE_CODE_INT: 1798 case TYPE_CODE_FLT: 1799 return TYPE_LENGTH (type); 1800 case TYPE_CODE_ARRAY: 1801 return hppa_alignof (TYPE_FIELD_TYPE (type, 0)); 1802 case TYPE_CODE_STRUCT: 1803 case TYPE_CODE_UNION: 1804 max_align = 1; 1805 for (i = 0; i < TYPE_NFIELDS (type); i++) 1806 { 1807 /* Bit fields have no real alignment. */ 1808 if (!TYPE_FIELD_BITPOS (type, i)) 1809 { 1810 align = hppa_alignof (TYPE_FIELD_TYPE (type, i)); 1811 max_align = max (max_align, align); 1812 } 1813 } 1814 return max_align; 1815 default: 1816 return 4; 1817 } 1818 } 1819 1820 /* Print the register regnum, or all registers if regnum is -1 */ 1821 1822 void 1823 pa_do_registers_info (regnum, fpregs) 1824 int regnum; 1825 int fpregs; 1826 { 1827 char raw_regs [REGISTER_BYTES]; 1828 int i; 1829 1830 for (i = 0; i < NUM_REGS; i++) 1831 read_relative_register_raw_bytes (i, raw_regs + REGISTER_BYTE (i)); 1832 if (regnum == -1) 1833 pa_print_registers (raw_regs, regnum, fpregs); 1834 else if (regnum < FP0_REGNUM) 1835 printf_unfiltered ("%s %x\n", reg_names[regnum], *(long *)(raw_regs + 1836 REGISTER_BYTE (regnum))); 1837 else 1838 pa_print_fp_reg (regnum); 1839 } 1840 1841 static void 1842 pa_print_registers (raw_regs, regnum, fpregs) 1843 char *raw_regs; 1844 int regnum; 1845 int fpregs; 1846 { 1847 int i,j; 1848 long val; 1849 1850 for (i = 0; i < 18; i++) 1851 { 1852 for (j = 0; j < 4; j++) 1853 { 1854 val = 1855 extract_signed_integer (raw_regs + REGISTER_BYTE (i+(j*18)), 4); 1856 printf_unfiltered ("%8.8s: %8x ", reg_names[i+(j*18)], val); 1857 } 1858 printf_unfiltered ("\n"); 1859 } 1860 1861 if (fpregs) 1862 for (i = 72; i < NUM_REGS; i++) 1863 pa_print_fp_reg (i); 1864 } 1865 1866 static void 1867 pa_print_fp_reg (i) 1868 int i; 1869 { 1870 unsigned char raw_buffer[MAX_REGISTER_RAW_SIZE]; 1871 unsigned char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE]; 1872 1873 /* Get 32bits of data. */ 1874 read_relative_register_raw_bytes (i, raw_buffer); 1875 1876 /* Put it in the buffer. No conversions are ever necessary. */ 1877 memcpy (virtual_buffer, raw_buffer, REGISTER_RAW_SIZE (i)); 1878 1879 fputs_filtered (reg_names[i], gdb_stdout); 1880 print_spaces_filtered (8 - strlen (reg_names[i]), gdb_stdout); 1881 fputs_filtered ("(single precision) ", gdb_stdout); 1882 1883 val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, gdb_stdout, 0, 1884 1, 0, Val_pretty_default); 1885 printf_filtered ("\n"); 1886 1887 /* If "i" is even, then this register can also be a double-precision 1888 FP register. Dump it out as such. */ 1889 if ((i % 2) == 0) 1890 { 1891 /* Get the data in raw format for the 2nd half. */ 1892 read_relative_register_raw_bytes (i + 1, raw_buffer); 1893 1894 /* Copy it into the appropriate part of the virtual buffer. */ 1895 memcpy (virtual_buffer + REGISTER_RAW_SIZE (i), raw_buffer, 1896 REGISTER_RAW_SIZE (i)); 1897 1898 /* Dump it as a double. */ 1899 fputs_filtered (reg_names[i], gdb_stdout); 1900 print_spaces_filtered (8 - strlen (reg_names[i]), gdb_stdout); 1901 fputs_filtered ("(double precision) ", gdb_stdout); 1902 1903 val_print (builtin_type_double, virtual_buffer, 0, gdb_stdout, 0, 1904 1, 0, Val_pretty_default); 1905 printf_filtered ("\n"); 1906 } 1907 } 1908 1909 /* Return one if PC is in the call path of a trampoline, else return zero. 1910 1911 Note we return one for *any* call trampoline (long-call, arg-reloc), not 1912 just shared library trampolines (import, export). */ 1913 1914 int 1915 in_solib_call_trampoline (pc, name) 1916 CORE_ADDR pc; 1917 char *name; 1918 { 1919 struct minimal_symbol *minsym; 1920 struct unwind_table_entry *u; 1921 static CORE_ADDR dyncall = 0; 1922 static CORE_ADDR sr4export = 0; 1923 1924 /* FIXME XXX - dyncall and sr4export must be initialized whenever we get a 1925 new exec file */ 1926 1927 /* First see if PC is in one of the two C-library trampolines. */ 1928 if (!dyncall) 1929 { 1930 minsym = lookup_minimal_symbol ("$$dyncall", NULL, NULL); 1931 if (minsym) 1932 dyncall = SYMBOL_VALUE_ADDRESS (minsym); 1933 else 1934 dyncall = -1; 1935 } 1936 1937 if (!sr4export) 1938 { 1939 minsym = lookup_minimal_symbol ("_sr4export", NULL, NULL); 1940 if (minsym) 1941 sr4export = SYMBOL_VALUE_ADDRESS (minsym); 1942 else 1943 sr4export = -1; 1944 } 1945 1946 if (pc == dyncall || pc == sr4export) 1947 return 1; 1948 1949 /* Get the unwind descriptor corresponding to PC, return zero 1950 if no unwind was found. */ 1951 u = find_unwind_entry (pc); 1952 if (!u) 1953 return 0; 1954 1955 /* If this isn't a linker stub, then return now. */ 1956 if (u->stub_type == 0) 1957 return 0; 1958 1959 /* By definition a long-branch stub is a call stub. */ 1960 if (u->stub_type == LONG_BRANCH) 1961 return 1; 1962 1963 /* The call and return path execute the same instructions within 1964 an IMPORT stub! So an IMPORT stub is both a call and return 1965 trampoline. */ 1966 if (u->stub_type == IMPORT) 1967 return 1; 1968 1969 /* Parameter relocation stubs always have a call path and may have a 1970 return path. */ 1971 if (u->stub_type == PARAMETER_RELOCATION 1972 || u->stub_type == EXPORT) 1973 { 1974 CORE_ADDR addr; 1975 1976 /* Search forward from the current PC until we hit a branch 1977 or the end of the stub. */ 1978 for (addr = pc; addr <= u->region_end; addr += 4) 1979 { 1980 unsigned long insn; 1981 1982 insn = read_memory_integer (addr, 4); 1983 1984 /* Does it look like a bl? If so then it's the call path, if 1985 we find a bv or be first, then we're on the return path. */ 1986 if ((insn & 0xfc00e000) == 0xe8000000) 1987 return 1; 1988 else if ((insn & 0xfc00e001) == 0xe800c000 1989 || (insn & 0xfc000000) == 0xe0000000) 1990 return 0; 1991 } 1992 1993 /* Should never happen. */ 1994 warning ("Unable to find branch in parameter relocation stub.\n"); 1995 return 0; 1996 } 1997 1998 /* Unknown stub type. For now, just return zero. */ 1999 return 0; 2000 } 2001 2002 /* Return one if PC is in the return path of a trampoline, else return zero. 2003 2004 Note we return one for *any* call trampoline (long-call, arg-reloc), not 2005 just shared library trampolines (import, export). */ 2006 2007 int 2008 in_solib_return_trampoline (pc, name) 2009 CORE_ADDR pc; 2010 char *name; 2011 { 2012 struct unwind_table_entry *u; 2013 2014 /* Get the unwind descriptor corresponding to PC, return zero 2015 if no unwind was found. */ 2016 u = find_unwind_entry (pc); 2017 if (!u) 2018 return 0; 2019 2020 /* If this isn't a linker stub or it's just a long branch stub, then 2021 return zero. */ 2022 if (u->stub_type == 0 || u->stub_type == LONG_BRANCH) 2023 return 0; 2024 2025 /* The call and return path execute the same instructions within 2026 an IMPORT stub! So an IMPORT stub is both a call and return 2027 trampoline. */ 2028 if (u->stub_type == IMPORT) 2029 return 1; 2030 2031 /* Parameter relocation stubs always have a call path and may have a 2032 return path. */ 2033 if (u->stub_type == PARAMETER_RELOCATION 2034 || u->stub_type == EXPORT) 2035 { 2036 CORE_ADDR addr; 2037 2038 /* Search forward from the current PC until we hit a branch 2039 or the end of the stub. */ 2040 for (addr = pc; addr <= u->region_end; addr += 4) 2041 { 2042 unsigned long insn; 2043 2044 insn = read_memory_integer (addr, 4); 2045 2046 /* Does it look like a bl? If so then it's the call path, if 2047 we find a bv or be first, then we're on the return path. */ 2048 if ((insn & 0xfc00e000) == 0xe8000000) 2049 return 0; 2050 else if ((insn & 0xfc00e001) == 0xe800c000 2051 || (insn & 0xfc000000) == 0xe0000000) 2052 return 1; 2053 } 2054 2055 /* Should never happen. */ 2056 warning ("Unable to find branch in parameter relocation stub.\n"); 2057 return 0; 2058 } 2059 2060 /* Unknown stub type. For now, just return zero. */ 2061 return 0; 2062 2063 } 2064 2065 /* Figure out if PC is in a trampoline, and if so find out where 2066 the trampoline will jump to. If not in a trampoline, return zero. 2067 2068 Simple code examination probably is not a good idea since the code 2069 sequences in trampolines can also appear in user code. 2070 2071 We use unwinds and information from the minimal symbol table to 2072 determine when we're in a trampoline. This won't work for ELF 2073 (yet) since it doesn't create stub unwind entries. Whether or 2074 not ELF will create stub unwinds or normal unwinds for linker 2075 stubs is still being debated. 2076 2077 This should handle simple calls through dyncall or sr4export, 2078 long calls, argument relocation stubs, and dyncall/sr4export 2079 calling an argument relocation stub. It even handles some stubs 2080 used in dynamic executables. */ 2081 2082 CORE_ADDR 2083 skip_trampoline_code (pc, name) 2084 CORE_ADDR pc; 2085 char *name; 2086 { 2087 long orig_pc = pc; 2088 long prev_inst, curr_inst, loc; 2089 static CORE_ADDR dyncall = 0; 2090 static CORE_ADDR sr4export = 0; 2091 struct minimal_symbol *msym; 2092 struct unwind_table_entry *u; 2093 2094 /* FIXME XXX - dyncall and sr4export must be initialized whenever we get a 2095 new exec file */ 2096 2097 if (!dyncall) 2098 { 2099 msym = lookup_minimal_symbol ("$$dyncall", NULL, NULL); 2100 if (msym) 2101 dyncall = SYMBOL_VALUE_ADDRESS (msym); 2102 else 2103 dyncall = -1; 2104 } 2105 2106 if (!sr4export) 2107 { 2108 msym = lookup_minimal_symbol ("_sr4export", NULL, NULL); 2109 if (msym) 2110 sr4export = SYMBOL_VALUE_ADDRESS (msym); 2111 else 2112 sr4export = -1; 2113 } 2114 2115 /* Addresses passed to dyncall may *NOT* be the actual address 2116 of the function. So we may have to do something special. */ 2117 if (pc == dyncall) 2118 { 2119 pc = (CORE_ADDR) read_register (22); 2120 2121 /* If bit 30 (counting from the left) is on, then pc is the address of 2122 the PLT entry for this function, not the address of the function 2123 itself. Bit 31 has meaning too, but only for MPE. */ 2124 if (pc & 0x2) 2125 pc = (CORE_ADDR) read_memory_integer (pc & ~0x3, 4); 2126 } 2127 else if (pc == sr4export) 2128 pc = (CORE_ADDR) (read_register (22)); 2129 2130 /* Get the unwind descriptor corresponding to PC, return zero 2131 if no unwind was found. */ 2132 u = find_unwind_entry (pc); 2133 if (!u) 2134 return 0; 2135 2136 /* If this isn't a linker stub, then return now. */ 2137 if (u->stub_type == 0) 2138 return orig_pc == pc ? 0 : pc & ~0x3; 2139 2140 /* It's a stub. Search for a branch and figure out where it goes. 2141 Note we have to handle multi insn branch sequences like ldil;ble. 2142 Most (all?) other branches can be determined by examining the contents 2143 of certain registers and the stack. */ 2144 loc = pc; 2145 curr_inst = 0; 2146 prev_inst = 0; 2147 while (1) 2148 { 2149 /* Make sure we haven't walked outside the range of this stub. */ 2150 if (u != find_unwind_entry (loc)) 2151 { 2152 warning ("Unable to find branch in linker stub"); 2153 return orig_pc == pc ? 0 : pc & ~0x3; 2154 } 2155 2156 prev_inst = curr_inst; 2157 curr_inst = read_memory_integer (loc, 4); 2158 2159 /* Does it look like a branch external using %r1? Then it's the 2160 branch from the stub to the actual function. */ 2161 if ((curr_inst & 0xffe0e000) == 0xe0202000) 2162 { 2163 /* Yup. See if the previous instruction loaded 2164 a value into %r1. If so compute and return the jump address. */ 2165 if ((prev_inst & 0xffe00000) == 0x20200000) 2166 return (extract_21 (prev_inst) + extract_17 (curr_inst)) & ~0x3; 2167 else 2168 { 2169 warning ("Unable to find ldil X,%%r1 before ble Y(%%sr4,%%r1)."); 2170 return orig_pc == pc ? 0 : pc & ~0x3; 2171 } 2172 } 2173 2174 /* Does it look like a be 0(sr0,%r21)? That's the branch from an 2175 import stub to an export stub. 2176 2177 It is impossible to determine the target of the branch via 2178 simple examination of instructions and/or data (consider 2179 that the address in the plabel may be the address of the 2180 bind-on-reference routine in the dynamic loader). 2181 2182 So we have try an alternative approach. 2183 2184 Get the name of the symbol at our current location; it should 2185 be a stub symbol with the same name as the symbol in the 2186 shared library. 2187 2188 Then lookup a minimal symbol with the same name; we should 2189 get the minimal symbol for the target routine in the shared 2190 library as those take precedence of import/export stubs. */ 2191 if (curr_inst == 0xe2a00000) 2192 { 2193 struct minimal_symbol *stubsym, *libsym; 2194 2195 stubsym = lookup_minimal_symbol_by_pc (loc); 2196 if (stubsym == NULL) 2197 { 2198 warning ("Unable to find symbol for 0x%x", loc); 2199 return orig_pc == pc ? 0 : pc & ~0x3; 2200 } 2201 2202 libsym = lookup_minimal_symbol (SYMBOL_NAME (stubsym), NULL, NULL); 2203 if (libsym == NULL) 2204 { 2205 warning ("Unable to find library symbol for %s\n", 2206 SYMBOL_NAME (stubsym)); 2207 return orig_pc == pc ? 0 : pc & ~0x3; 2208 } 2209 2210 return SYMBOL_VALUE (libsym); 2211 } 2212 2213 /* Does it look like bl X,%rp or bl X,%r0? Another way to do a 2214 branch from the stub to the actual function. */ 2215 else if ((curr_inst & 0xffe0e000) == 0xe8400000 2216 || (curr_inst & 0xffe0e000) == 0xe8000000) 2217 return (loc + extract_17 (curr_inst) + 8) & ~0x3; 2218 2219 /* Does it look like bv (rp)? Note this depends on the 2220 current stack pointer being the same as the stack 2221 pointer in the stub itself! This is a branch on from the 2222 stub back to the original caller. */ 2223 else if ((curr_inst & 0xffe0e000) == 0xe840c000) 2224 { 2225 /* Yup. See if the previous instruction loaded 2226 rp from sp - 8. */ 2227 if (prev_inst == 0x4bc23ff1) 2228 return (read_memory_integer 2229 (read_register (SP_REGNUM) - 8, 4)) & ~0x3; 2230 else 2231 { 2232 warning ("Unable to find restore of %%rp before bv (%%rp)."); 2233 return orig_pc == pc ? 0 : pc & ~0x3; 2234 } 2235 } 2236 2237 /* What about be,n 0(sr0,%rp)? It's just another way we return to 2238 the original caller from the stub. Used in dynamic executables. */ 2239 else if (curr_inst == 0xe0400002) 2240 { 2241 /* The value we jump to is sitting in sp - 24. But that's 2242 loaded several instructions before the be instruction. 2243 I guess we could check for the previous instruction being 2244 mtsp %r1,%sr0 if we want to do sanity checking. */ 2245 return (read_memory_integer 2246 (read_register (SP_REGNUM) - 24, 4)) & ~0x3; 2247 } 2248 2249 /* Haven't found the branch yet, but we're still in the stub. 2250 Keep looking. */ 2251 loc += 4; 2252 } 2253 } 2254 2255 /* For the given instruction (INST), return any adjustment it makes 2256 to the stack pointer or zero for no adjustment. 2257 2258 This only handles instructions commonly found in prologues. */ 2259 2260 static int 2261 prologue_inst_adjust_sp (inst) 2262 unsigned long inst; 2263 { 2264 /* This must persist across calls. */ 2265 static int save_high21; 2266 2267 /* The most common way to perform a stack adjustment ldo X(sp),sp */ 2268 if ((inst & 0xffffc000) == 0x37de0000) 2269 return extract_14 (inst); 2270 2271 /* stwm X,D(sp) */ 2272 if ((inst & 0xffe00000) == 0x6fc00000) 2273 return extract_14 (inst); 2274 2275 /* addil high21,%r1; ldo low11,(%r1),%r30) 2276 save high bits in save_high21 for later use. */ 2277 if ((inst & 0xffe00000) == 0x28200000) 2278 { 2279 save_high21 = extract_21 (inst); 2280 return 0; 2281 } 2282 2283 if ((inst & 0xffff0000) == 0x343e0000) 2284 return save_high21 + extract_14 (inst); 2285 2286 /* fstws as used by the HP compilers. */ 2287 if ((inst & 0xffffffe0) == 0x2fd01220) 2288 return extract_5_load (inst); 2289 2290 /* No adjustment. */ 2291 return 0; 2292 } 2293 2294 /* Return nonzero if INST is a branch of some kind, else return zero. */ 2295 2296 static int 2297 is_branch (inst) 2298 unsigned long inst; 2299 { 2300 switch (inst >> 26) 2301 { 2302 case 0x20: 2303 case 0x21: 2304 case 0x22: 2305 case 0x23: 2306 case 0x28: 2307 case 0x29: 2308 case 0x2a: 2309 case 0x2b: 2310 case 0x30: 2311 case 0x31: 2312 case 0x32: 2313 case 0x33: 2314 case 0x38: 2315 case 0x39: 2316 case 0x3a: 2317 return 1; 2318 2319 default: 2320 return 0; 2321 } 2322 } 2323 2324 /* Return the register number for a GR which is saved by INST or 2325 zero it INST does not save a GR. */ 2326 2327 static int 2328 inst_saves_gr (inst) 2329 unsigned long inst; 2330 { 2331 /* Does it look like a stw? */ 2332 if ((inst >> 26) == 0x1a) 2333 return extract_5R_store (inst); 2334 2335 /* Does it look like a stwm? GCC & HPC may use this in prologues. */ 2336 if ((inst >> 26) == 0x1b) 2337 return extract_5R_store (inst); 2338 2339 /* Does it look like sth or stb? HPC versions 9.0 and later use these 2340 too. */ 2341 if ((inst >> 26) == 0x19 || (inst >> 26) == 0x18) 2342 return extract_5R_store (inst); 2343 2344 return 0; 2345 } 2346 2347 /* Return the register number for a FR which is saved by INST or 2348 zero it INST does not save a FR. 2349 2350 Note we only care about full 64bit register stores (that's the only 2351 kind of stores the prologue will use). 2352 2353 FIXME: What about argument stores with the HP compiler in ANSI mode? */ 2354 2355 static int 2356 inst_saves_fr (inst) 2357 unsigned long inst; 2358 { 2359 if ((inst & 0xfc00dfc0) == 0x2c001200) 2360 return extract_5r_store (inst); 2361 return 0; 2362 } 2363 2364 /* Advance PC across any function entry prologue instructions 2365 to reach some "real" code. 2366 2367 Use information in the unwind table to determine what exactly should 2368 be in the prologue. */ 2369 2370 CORE_ADDR 2371 skip_prologue (pc) 2372 CORE_ADDR pc; 2373 { 2374 char buf[4]; 2375 CORE_ADDR orig_pc = pc; 2376 unsigned long inst, stack_remaining, save_gr, save_fr, save_rp, save_sp; 2377 unsigned long args_stored, status, i, restart_gr, restart_fr; 2378 struct unwind_table_entry *u; 2379 2380 restart_gr = 0; 2381 restart_fr = 0; 2382 2383 restart: 2384 u = find_unwind_entry (pc); 2385 if (!u) 2386 return pc; 2387 2388 /* If we are not at the beginning of a function, then return now. */ 2389 if ((pc & ~0x3) != u->region_start) 2390 return pc; 2391 2392 /* This is how much of a frame adjustment we need to account for. */ 2393 stack_remaining = u->Total_frame_size << 3; 2394 2395 /* Magic register saves we want to know about. */ 2396 save_rp = u->Save_RP; 2397 save_sp = u->Save_SP; 2398 2399 /* An indication that args may be stored into the stack. Unfortunately 2400 the HPUX compilers tend to set this in cases where no args were 2401 stored too!. */ 2402 args_stored = 1; 2403 2404 /* Turn the Entry_GR field into a bitmask. */ 2405 save_gr = 0; 2406 for (i = 3; i < u->Entry_GR + 3; i++) 2407 { 2408 /* Frame pointer gets saved into a special location. */ 2409 if (u->Save_SP && i == FP_REGNUM) 2410 continue; 2411 2412 save_gr |= (1 << i); 2413 } 2414 save_gr &= ~restart_gr; 2415 2416 /* Turn the Entry_FR field into a bitmask too. */ 2417 save_fr = 0; 2418 for (i = 12; i < u->Entry_FR + 12; i++) 2419 save_fr |= (1 << i); 2420 save_fr &= ~restart_fr; 2421 2422 /* Loop until we find everything of interest or hit a branch. 2423 2424 For unoptimized GCC code and for any HP CC code this will never ever 2425 examine any user instructions. 2426 2427 For optimzied GCC code we're faced with problems. GCC will schedule 2428 its prologue and make prologue instructions available for delay slot 2429 filling. The end result is user code gets mixed in with the prologue 2430 and a prologue instruction may be in the delay slot of the first branch 2431 or call. 2432 2433 Some unexpected things are expected with debugging optimized code, so 2434 we allow this routine to walk past user instructions in optimized 2435 GCC code. */ 2436 while (save_gr || save_fr || save_rp || save_sp || stack_remaining > 0 2437 || args_stored) 2438 { 2439 unsigned int reg_num; 2440 unsigned long old_stack_remaining, old_save_gr, old_save_fr; 2441 unsigned long old_save_rp, old_save_sp, next_inst; 2442 2443 /* Save copies of all the triggers so we can compare them later 2444 (only for HPC). */ 2445 old_save_gr = save_gr; 2446 old_save_fr = save_fr; 2447 old_save_rp = save_rp; 2448 old_save_sp = save_sp; 2449 old_stack_remaining = stack_remaining; 2450 2451 status = target_read_memory (pc, buf, 4); 2452 inst = extract_unsigned_integer (buf, 4); 2453 2454 /* Yow! */ 2455 if (status != 0) 2456 return pc; 2457 2458 /* Note the interesting effects of this instruction. */ 2459 stack_remaining -= prologue_inst_adjust_sp (inst); 2460 2461 /* There is only one instruction used for saving RP into the stack. */ 2462 if (inst == 0x6bc23fd9) 2463 save_rp = 0; 2464 2465 /* This is the only way we save SP into the stack. At this time 2466 the HP compilers never bother to save SP into the stack. */ 2467 if ((inst & 0xffffc000) == 0x6fc10000) 2468 save_sp = 0; 2469 2470 /* Account for general and floating-point register saves. */ 2471 reg_num = inst_saves_gr (inst); 2472 save_gr &= ~(1 << reg_num); 2473 2474 /* Ugh. Also account for argument stores into the stack. 2475 Unfortunately args_stored only tells us that some arguments 2476 where stored into the stack. Not how many or what kind! 2477 2478 This is a kludge as on the HP compiler sets this bit and it 2479 never does prologue scheduling. So once we see one, skip past 2480 all of them. We have similar code for the fp arg stores below. 2481 2482 FIXME. Can still die if we have a mix of GR and FR argument 2483 stores! */ 2484 if (reg_num >= 23 && reg_num <= 26) 2485 { 2486 while (reg_num >= 23 && reg_num <= 26) 2487 { 2488 pc += 4; 2489 status = target_read_memory (pc, buf, 4); 2490 inst = extract_unsigned_integer (buf, 4); 2491 if (status != 0) 2492 return pc; 2493 reg_num = inst_saves_gr (inst); 2494 } 2495 args_stored = 0; 2496 continue; 2497 } 2498 2499 reg_num = inst_saves_fr (inst); 2500 save_fr &= ~(1 << reg_num); 2501 2502 status = target_read_memory (pc + 4, buf, 4); 2503 next_inst = extract_unsigned_integer (buf, 4); 2504 2505 /* Yow! */ 2506 if (status != 0) 2507 return pc; 2508 2509 /* We've got to be read to handle the ldo before the fp register 2510 save. */ 2511 if ((inst & 0xfc000000) == 0x34000000 2512 && inst_saves_fr (next_inst) >= 4 2513 && inst_saves_fr (next_inst) <= 7) 2514 { 2515 /* So we drop into the code below in a reasonable state. */ 2516 reg_num = inst_saves_fr (next_inst); 2517 pc -= 4; 2518 } 2519 2520 /* Ugh. Also account for argument stores into the stack. 2521 This is a kludge as on the HP compiler sets this bit and it 2522 never does prologue scheduling. So once we see one, skip past 2523 all of them. */ 2524 if (reg_num >= 4 && reg_num <= 7) 2525 { 2526 while (reg_num >= 4 && reg_num <= 7) 2527 { 2528 pc += 8; 2529 status = target_read_memory (pc, buf, 4); 2530 inst = extract_unsigned_integer (buf, 4); 2531 if (status != 0) 2532 return pc; 2533 if ((inst & 0xfc000000) != 0x34000000) 2534 break; 2535 status = target_read_memory (pc + 4, buf, 4); 2536 next_inst = extract_unsigned_integer (buf, 4); 2537 if (status != 0) 2538 return pc; 2539 reg_num = inst_saves_fr (next_inst); 2540 } 2541 args_stored = 0; 2542 continue; 2543 } 2544 2545 /* Quit if we hit any kind of branch. This can happen if a prologue 2546 instruction is in the delay slot of the first call/branch. */ 2547 if (is_branch (inst)) 2548 break; 2549 2550 /* What a crock. The HP compilers set args_stored even if no 2551 arguments were stored into the stack (boo hiss). This could 2552 cause this code to then skip a bunch of user insns (up to the 2553 first branch). 2554 2555 To combat this we try to identify when args_stored was bogusly 2556 set and clear it. We only do this when args_stored is nonzero, 2557 all other resources are accounted for, and nothing changed on 2558 this pass. */ 2559 if (args_stored 2560 && ! (save_gr || save_fr || save_rp || save_sp || stack_remaining > 0) 2561 && old_save_gr == save_gr && old_save_fr == save_fr 2562 && old_save_rp == save_rp && old_save_sp == save_sp 2563 && old_stack_remaining == stack_remaining) 2564 break; 2565 2566 /* Bump the PC. */ 2567 pc += 4; 2568 } 2569 2570 /* We've got a tenative location for the end of the prologue. However 2571 because of limitations in the unwind descriptor mechanism we may 2572 have went too far into user code looking for the save of a register 2573 that does not exist. So, if there registers we expected to be saved 2574 but never were, mask them out and restart. 2575 2576 This should only happen in optimized code, and should be very rare. */ 2577 if (save_gr || (save_fr && ! (restart_fr || restart_gr))) 2578 { 2579 pc = orig_pc; 2580 restart_gr = save_gr; 2581 restart_fr = save_fr; 2582 goto restart; 2583 } 2584 2585 return pc; 2586 } 2587 2588 /* Put here the code to store, into a struct frame_saved_regs, 2589 the addresses of the saved registers of frame described by FRAME_INFO. 2590 This includes special registers such as pc and fp saved in special 2591 ways in the stack frame. sp is even more special: 2592 the address we return for it IS the sp for the next frame. */ 2593 2594 void 2595 hppa_frame_find_saved_regs (frame_info, frame_saved_regs) 2596 struct frame_info *frame_info; 2597 struct frame_saved_regs *frame_saved_regs; 2598 { 2599 CORE_ADDR pc; 2600 struct unwind_table_entry *u; 2601 unsigned long inst, stack_remaining, save_gr, save_fr, save_rp, save_sp; 2602 int status, i, reg; 2603 char buf[4]; 2604 int fp_loc = -1; 2605 2606 /* Zero out everything. */ 2607 memset (frame_saved_regs, '\0', sizeof (struct frame_saved_regs)); 2608 2609 /* Call dummy frames always look the same, so there's no need to 2610 examine the dummy code to determine locations of saved registers; 2611 instead, let find_dummy_frame_regs fill in the correct offsets 2612 for the saved registers. */ 2613 if ((frame_info->pc >= frame_info->frame 2614 && frame_info->pc <= (frame_info->frame + CALL_DUMMY_LENGTH 2615 + 32 * 4 + (NUM_REGS - FP0_REGNUM) * 8 2616 + 6 * 4))) 2617 find_dummy_frame_regs (frame_info, frame_saved_regs); 2618 2619 /* Interrupt handlers are special too. They lay out the register 2620 state in the exact same order as the register numbers in GDB. */ 2621 if (pc_in_interrupt_handler (frame_info->pc)) 2622 { 2623 for (i = 0; i < NUM_REGS; i++) 2624 { 2625 /* SP is a little special. */ 2626 if (i == SP_REGNUM) 2627 frame_saved_regs->regs[SP_REGNUM] 2628 = read_memory_integer (frame_info->frame + SP_REGNUM * 4, 4); 2629 else 2630 frame_saved_regs->regs[i] = frame_info->frame + i * 4; 2631 } 2632 return; 2633 } 2634 2635 #ifdef FRAME_FIND_SAVED_REGS_IN_SIGTRAMP 2636 /* Handle signal handler callers. */ 2637 if (frame_info->signal_handler_caller) 2638 { 2639 FRAME_FIND_SAVED_REGS_IN_SIGTRAMP (frame_info, frame_saved_regs); 2640 return; 2641 } 2642 #endif 2643 2644 /* Get the starting address of the function referred to by the PC 2645 saved in frame. */ 2646 pc = get_pc_function_start (frame_info->pc); 2647 2648 /* Yow! */ 2649 u = find_unwind_entry (pc); 2650 if (!u) 2651 return; 2652 2653 /* This is how much of a frame adjustment we need to account for. */ 2654 stack_remaining = u->Total_frame_size << 3; 2655 2656 /* Magic register saves we want to know about. */ 2657 save_rp = u->Save_RP; 2658 save_sp = u->Save_SP; 2659 2660 /* Turn the Entry_GR field into a bitmask. */ 2661 save_gr = 0; 2662 for (i = 3; i < u->Entry_GR + 3; i++) 2663 { 2664 /* Frame pointer gets saved into a special location. */ 2665 if (u->Save_SP && i == FP_REGNUM) 2666 continue; 2667 2668 save_gr |= (1 << i); 2669 } 2670 2671 /* Turn the Entry_FR field into a bitmask too. */ 2672 save_fr = 0; 2673 for (i = 12; i < u->Entry_FR + 12; i++) 2674 save_fr |= (1 << i); 2675 2676 /* The frame always represents the value of %sp at entry to the 2677 current function (and is thus equivalent to the "saved" stack 2678 pointer. */ 2679 frame_saved_regs->regs[SP_REGNUM] = frame_info->frame; 2680 2681 /* Loop until we find everything of interest or hit a branch. 2682 2683 For unoptimized GCC code and for any HP CC code this will never ever 2684 examine any user instructions. 2685 2686 For optimzied GCC code we're faced with problems. GCC will schedule 2687 its prologue and make prologue instructions available for delay slot 2688 filling. The end result is user code gets mixed in with the prologue 2689 and a prologue instruction may be in the delay slot of the first branch 2690 or call. 2691 2692 Some unexpected things are expected with debugging optimized code, so 2693 we allow this routine to walk past user instructions in optimized 2694 GCC code. */ 2695 while (save_gr || save_fr || save_rp || save_sp || stack_remaining > 0) 2696 { 2697 status = target_read_memory (pc, buf, 4); 2698 inst = extract_unsigned_integer (buf, 4); 2699 2700 /* Yow! */ 2701 if (status != 0) 2702 return; 2703 2704 /* Note the interesting effects of this instruction. */ 2705 stack_remaining -= prologue_inst_adjust_sp (inst); 2706 2707 /* There is only one instruction used for saving RP into the stack. */ 2708 if (inst == 0x6bc23fd9) 2709 { 2710 save_rp = 0; 2711 frame_saved_regs->regs[RP_REGNUM] = frame_info->frame - 20; 2712 } 2713 2714 /* Just note that we found the save of SP into the stack. The 2715 value for frame_saved_regs was computed above. */ 2716 if ((inst & 0xffffc000) == 0x6fc10000) 2717 save_sp = 0; 2718 2719 /* Account for general and floating-point register saves. */ 2720 reg = inst_saves_gr (inst); 2721 if (reg >= 3 && reg <= 18 2722 && (!u->Save_SP || reg != FP_REGNUM)) 2723 { 2724 save_gr &= ~(1 << reg); 2725 2726 /* stwm with a positive displacement is a *post modify*. */ 2727 if ((inst >> 26) == 0x1b 2728 && extract_14 (inst) >= 0) 2729 frame_saved_regs->regs[reg] = frame_info->frame; 2730 else 2731 { 2732 /* Handle code with and without frame pointers. */ 2733 if (u->Save_SP) 2734 frame_saved_regs->regs[reg] 2735 = frame_info->frame + extract_14 (inst); 2736 else 2737 frame_saved_regs->regs[reg] 2738 = frame_info->frame + (u->Total_frame_size << 3) 2739 + extract_14 (inst); 2740 } 2741 } 2742 2743 2744 /* GCC handles callee saved FP regs a little differently. 2745 2746 It emits an instruction to put the value of the start of 2747 the FP store area into %r1. It then uses fstds,ma with 2748 a basereg of %r1 for the stores. 2749 2750 HP CC emits them at the current stack pointer modifying 2751 the stack pointer as it stores each register. */ 2752 2753 /* ldo X(%r3),%r1 or ldo X(%r30),%r1. */ 2754 if ((inst & 0xffffc000) == 0x34610000 2755 || (inst & 0xffffc000) == 0x37c10000) 2756 fp_loc = extract_14 (inst); 2757 2758 reg = inst_saves_fr (inst); 2759 if (reg >= 12 && reg <= 21) 2760 { 2761 /* Note +4 braindamage below is necessary because the FP status 2762 registers are internally 8 registers rather than the expected 2763 4 registers. */ 2764 save_fr &= ~(1 << reg); 2765 if (fp_loc == -1) 2766 { 2767 /* 1st HP CC FP register store. After this instruction 2768 we've set enough state that the GCC and HPCC code are 2769 both handled in the same manner. */ 2770 frame_saved_regs->regs[reg + FP4_REGNUM + 4] = frame_info->frame; 2771 fp_loc = 8; 2772 } 2773 else 2774 { 2775 frame_saved_regs->regs[reg + FP0_REGNUM + 4] 2776 = frame_info->frame + fp_loc; 2777 fp_loc += 8; 2778 } 2779 } 2780 2781 /* Quit if we hit any kind of branch. This can happen if a prologue 2782 instruction is in the delay slot of the first call/branch. */ 2783 if (is_branch (inst)) 2784 break; 2785 2786 /* Bump the PC. */ 2787 pc += 4; 2788 } 2789 } 2790 2791 #ifdef MAINTENANCE_CMDS 2792 2793 static void 2794 unwind_command (exp, from_tty) 2795 char *exp; 2796 int from_tty; 2797 { 2798 CORE_ADDR address; 2799 struct unwind_table_entry *u; 2800 2801 /* If we have an expression, evaluate it and use it as the address. */ 2802 2803 if (exp != 0 && *exp != 0) 2804 address = parse_and_eval_address (exp); 2805 else 2806 return; 2807 2808 u = find_unwind_entry (address); 2809 2810 if (!u) 2811 { 2812 printf_unfiltered ("Can't find unwind table entry for %s\n", exp); 2813 return; 2814 } 2815 2816 printf_unfiltered ("unwind_table_entry (0x%x):\n", u); 2817 2818 printf_unfiltered ("\tregion_start = "); 2819 print_address (u->region_start, gdb_stdout); 2820 2821 printf_unfiltered ("\n\tregion_end = "); 2822 print_address (u->region_end, gdb_stdout); 2823 2824 #ifdef __STDC__ 2825 #define pif(FLD) if (u->FLD) printf_unfiltered (" "#FLD); 2826 #else 2827 #define pif(FLD) if (u->FLD) printf_unfiltered (" FLD"); 2828 #endif 2829 2830 printf_unfiltered ("\n\tflags ="); 2831 pif (Cannot_unwind); 2832 pif (Millicode); 2833 pif (Millicode_save_sr0); 2834 pif (Entry_SR); 2835 pif (Args_stored); 2836 pif (Variable_Frame); 2837 pif (Separate_Package_Body); 2838 pif (Frame_Extension_Millicode); 2839 pif (Stack_Overflow_Check); 2840 pif (Two_Instruction_SP_Increment); 2841 pif (Ada_Region); 2842 pif (Save_SP); 2843 pif (Save_RP); 2844 pif (Save_MRP_in_frame); 2845 pif (extn_ptr_defined); 2846 pif (Cleanup_defined); 2847 pif (MPE_XL_interrupt_marker); 2848 pif (HP_UX_interrupt_marker); 2849 pif (Large_frame); 2850 2851 putchar_unfiltered ('\n'); 2852 2853 #ifdef __STDC__ 2854 #define pin(FLD) printf_unfiltered ("\t"#FLD" = 0x%x\n", u->FLD); 2855 #else 2856 #define pin(FLD) printf_unfiltered ("\tFLD = 0x%x\n", u->FLD); 2857 #endif 2858 2859 pin (Region_description); 2860 pin (Entry_FR); 2861 pin (Entry_GR); 2862 pin (Total_frame_size); 2863 } 2864 #endif /* MAINTENANCE_CMDS */ 2865 2866 void 2867 _initialize_hppa_tdep () 2868 { 2869 tm_print_insn = print_insn_hppa; 2870 2871 #ifdef MAINTENANCE_CMDS 2872 add_cmd ("unwind", class_maintenance, unwind_command, 2873 "Print unwind table entry at given address.", 2874 &maintenanceprintlist); 2875 #endif /* MAINTENANCE_CMDS */ 2876 } 2877