gdb/hppabsd-tdep.c

   1 /* Machine-dependent code which would otherwise be in inflow.c and core.c,
   2    for GDB, the GNU debugger.  This code is for the HP PA-RISC cpu.
   3    Copyright 1986, 1987, 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
   4
   5    Contributed by the Center for Software Science at the
   6    University of Utah ([email protected]).
   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., 675 Mass Ave, Cambridge, MA 02139, 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 <sys/dir.h>
  38 #include <signal.h>
  39 #include <sys/ioctl.h>
  40
  41 #ifdef COFF_ENCAPSULATE
  42 #include "a.out.encap.h"
  43 #else
  44 #include <a.out.h>
  45 #endif
  46 #ifndef N_SET_MAGIC
  47 #define N_SET_MAGIC(exec, val) ((exec).a_magic = (val))
  48 #endif
  49
  50 /*#include <sys/user.h>         After a.out.h  */
  51 #include <sys/file.h>
  52 #include <sys/stat.h>
  53 #include <sys/ptrace.h>
  54 #include <machine/psl.h>
  55
  56 #ifdef KERNELDEBUG
  57 #include <sys/vmmac.h>
  58 #include <machine/machparam.h>
  59 #include <machine/vmparam.h>
  60 #include <machine/pde.h>
  61 #include <machine/cpu.h>
  62 #include <machine/iomod.h>
  63 #include <machine/pcb.h>
  64 #include <machine/rpb.h>
  65 #include <ctype.h>
  66
  67 extern int kernel_debugging;
  68 extern CORE_ADDR startup_file_start;
  69 extern CORE_ADDR startup_file_end;
  70
  71 #define KERNOFF         ((unsigned)KERNBASE)
  72 #define INKERNEL(x)     ((x) >= KERNOFF && (x) < KERNOFF + ctob(slr))
  73
  74 static int ok_to_cache();
  75 static void set_kernel_boundaries();
  76
  77 int devmem = 0;
  78 int vtophys_ready = 0;
  79 int kerneltype;
  80 #define OS_BSD  1
  81 #define OS_MACH 2
  82 #endif
  83
  84 #include "gdbcore.h"
  85 #include "gdbcmd.h"
  86
  87 extern int errno;
  88 \f
  89
  90
  91
  92
  93
  94 /* Last modification time of executable file.
  95    Also used in source.c to compare against mtime of a source file.  */
  96
  97 extern int exec_mtime;
  98
  99 /* Virtual addresses of bounds of the two areas of memory in the core file.  */
 100
 101 /* extern CORE_ADDR data_start; */
 102 extern CORE_ADDR data_end;
 103 extern CORE_ADDR stack_start;
 104 extern CORE_ADDR stack_end;
 105
 106 /* Virtual addresses of bounds of two areas of memory in the exec file.
 107    Note that the data area in the exec file is used only when there is no core file.  */
 108
 109 extern CORE_ADDR text_start;
 110 extern CORE_ADDR text_end;
 111
 112 extern CORE_ADDR exec_data_start;
 113 extern CORE_ADDR exec_data_end;
 114
 115 /* Address in executable file of start of text area data.  */
 116
 117 extern int text_offset;
 118
 119 /* Address in executable file of start of data area data.  */
 120
 121 extern int exec_data_offset;
 122
 123 /* Address in core file of start of data area data.  */
 124
 125 extern int data_offset;
 126
 127 /* Address in core file of start of stack area data.  */
 128
 129 extern int stack_offset;
 130
 131 struct header file_hdr;
 132 struct som_exec_auxhdr exec_hdr;
 133 \f
 134 #ifdef KERNELDEBUG
 135 /*
 136  * Kernel debugging routines.
 137  */
 138
 139 static struct pcb pcb;
 140 static struct pde *pdir;
 141 static struct hte *htbl;
 142 static u_int npdir, nhtbl;
 143
 144 static CORE_ADDR
 145 ksym_lookup(name)
 146         char *name;
 147 {
 148         struct symbol *sym;
 149         int i;
 150
 151         if ((i = lookup_misc_func(name)) < 0)
 152                 error("kernel symbol `%s' not found.", name);
 153
 154         return (misc_function_vector[i].address);
 155 }
 156
 157 /*
 158  * (re-)set the variables that tell "inside_entry_file" where to end
 159  * a stack backtrace.
 160  */
 161 void
 162 set_kernel_boundaries()
 163 {
 164         switch (kerneltype) {
 165         case OS_MACH:
 166                 startup_file_start = ksym_lookup("$syscall");
 167                 startup_file_end = ksym_lookup("trap");
 168                 break;
 169         case OS_BSD:
 170                 startup_file_start = ksym_lookup("syscallinit");
 171                 startup_file_end = ksym_lookup("$syscallexit");
 172                 break;
 173         }
 174 }
 175
 176 /*
 177  * return true if 'len' bytes starting at 'addr' can be read out as
 178  * longwords and/or locally cached (this is mostly for memory mapped
 179  * i/o register access when debugging remote kernels).
 180  */
 181 static int
 182 ok_to_cache(addr, len)
 183 {
 184         static CORE_ADDR ioptr;
 185
 186         if (! ioptr)
 187                 ioptr = ksym_lookup("ioptr");
 188
 189         if (addr >= ioptr && addr < SPA_HIGH)
 190                 return (0);
 191
 192         return (1);
 193 }
 194
 195 static
 196 physrd(addr, dat, len)
 197         u_int addr;
 198         char *dat;
 199 {
 200         if (lseek(corechan, addr, L_SET) == -1)
 201                 return (-1);
 202         if (read(corechan, dat, len) != len)
 203                 return (-1);
 204
 205         return (0);
 206 }
 207
 208 /*
 209  * When looking at kernel data space through /dev/mem or with a core file, do
 210  * virtual memory mapping.
 211  */
 212 static CORE_ADDR
 213 vtophys(space, addr)
 214         unsigned space;
 215         CORE_ADDR addr;
 216 {
 217         struct pde *pptr;
 218         u_int hindx, vpageno, ppageno;
 219         CORE_ADDR phys = ~0;
 220
 221         if (!vtophys_ready) {
 222                 phys = addr;            /* XXX for kvread */
 223         } else if (kerneltype == OS_BSD) {
 224                 /* make offset into a virtual page no */
 225                 vpageno = btop(addr);
 226                 /*
 227                  *  Determine index into hash table, initialize pptr to this
 228                  *  entry (since first word of pte & hte are same), and set
 229                  *  physical page number for first entry in chain.
 230                  */
 231                 hindx = pdirhash(space, addr) & (nhtbl-1);
 232                 pptr = (struct pde *) &htbl[hindx];
 233                 ppageno = pptr->pde_next;
 234                 while (1) {
 235                         if (pptr->pde_end)
 236                                 break;
 237                         pptr = &pdir[ppageno];
 238                         /*
 239                          *  If space id & virtual page number match, return
 240                          *  "next PDIR entry of previous PDIR entry" as the
 241                          *  physical page or'd with offset into page.
 242                          */
 243                         if (pptr->pde_space == space &&
 244                             pptr->pde_page == vpageno) {
 245                                 phys = (CORE_ADDR) ((u_int)ptob(ppageno) |
 246                                                     (addr & PGOFSET));
 247                                 break;
 248                         }
 249                         ppageno = pptr->pde_next;
 250                 }
 251         }
 252 #ifdef MACHKERNELDEBUG
 253         else if (kerneltype == OS_MACH) {
 254           mach_vtophys(space, addr, &phys);
 255         }
 256 #endif
 257 #if 0
 258         printf("vtophys(%x.%x) -> %x\n", space, addr, phys);
 259 #endif
 260         return (phys);
 261 }
 262
 263 static
 264 kvread(addr)
 265         CORE_ADDR addr;
 266 {
 267         CORE_ADDR paddr;
 268
 269         paddr = vtophys(0, addr);
 270         if (paddr != ~0)
 271                 if (physrd(paddr, (char *)&addr, sizeof(addr)) == 0)
 272                         return (addr);
 273
 274         return (~0);
 275 }
 276
 277 static void
 278 read_pcb(addr)
 279      u_int addr;
 280 {
 281         int i, off;
 282         extern char registers[];
 283         static int reg2pcb[] = {
 284                 /* RPB */
 285                 -1,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
 286                 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
 287                 45, 52, 51, 75, 74, 49, 53, 54, 55, 56, -1, 70, 66, 67, 68, 69,
 288                 71, 72, 73, 34, 42, 43, 44, 46, 47, 58, 59, 60, -1, -1, -1, -1,
 289                 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 290                 -1, -1, -1, -1,
 291                 /* BSD */
 292                 -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
 293                 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
 294                 43, 64, 67, 68, 67, 47, 51, 52, 53, 54, -1, 35, 31, 32, 33, 34,
 295                 36, 37, 38, 39, 40, 41, 42, 44, 45, 56, 57, 58,102,103,104, -1,
 296                 70, 71, 72, 73, 74, 75, 76, 77, 78, 80, 82, 84, 86, 88, 90, 92,
 297                 94, 96, 98, 100,
 298                 /* Mach */
 299                 -1, -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13,
 300                 14, 15, 16, -1, -1, -1, -1, -1, -1, -1, -1, 17, -1, -1, 18, -1,
 301                 25, -1, -1, -1, -1, 30, -1, -1, -1, -1, -1, 20, -1, -1, -1, 19,
 302                 21, 22, 23, 24, 26, 27, -1, 28, 29, -1, -1, -1, -1, -1, -1, -1,
 303                 34, 35, 36, 37, 38, 39, 40, 41, -1, -1, -1, -1, -1, -1, -1, -1,
 304                 42, 44, 46, 48
 305         };
 306         static struct rpb *rpbaddr = (struct rpb *) 0;
 307         static u_int rpbpcbaddr = 0;
 308
 309         if (!remote_debugging) {
 310                 /*
 311                  * If we are debugging a post-mortem and this is the first
 312                  * call of read_pcb, read the RPB.  Also assoicate the
 313                  * thread/proc running at the time with the RPB.
 314                  */
 315                 if (!devmem && rpbpcbaddr == 0) {
 316                         CORE_ADDR raddr = ksym_lookup("rpb");
 317                         int usepcb = 1;
 318
 319                         if (raddr != ~0) {
 320                                 rpbaddr = (struct rpb *) malloc(sizeof *rpbaddr);
 321                                 if (!physrd(raddr, (char *)rpbaddr, sizeof *rpbaddr)) {
 322                                         rpbpcbaddr = addr;
 323                                         usepcb = 0;
 324                                 }
 325                         }
 326                         if (usepcb) {
 327                                 error("cannot read rpb, using pcb for registers\n");
 328                                 if (rpbaddr)
 329                                         free((char *)rpbaddr);
 330                                 rpbpcbaddr = ~0;
 331                         }
 332                 }
 333                 if (physrd (addr, (char *)&pcb, sizeof pcb))
 334                         error ("cannot read pcb at %x.\n", addr);
 335         } else {
 336                 if (remote_read_inferior_memory(addr, (char *)&pcb, sizeof pcb))
 337                         error ("cannot read pcb at %x.\n", addr);
 338         }
 339
 340         if (kerneltype == OS_BSD) {
 341                 printf("p0br %lx p0lr %lx p1br %lx p1lr %lx\n",
 342                        pcb.pcb_p0br, pcb.pcb_p0lr, pcb.pcb_p1br, pcb.pcb_p1lr);
 343                 off = NUM_REGS;
 344         } else {
 345                 printf("pcb %lx psw %lx ksp %lx\n",
 346                        addr, ((int *)&pcb)[31], ((int *)&pcb)[32]);
 347                 off = NUM_REGS * 2;
 348         }
 349         /*
 350          * get the register values out of the sys pcb and
 351          * store them where `read_register' will find them.
 352          */
 353         bzero(registers, REGISTER_BYTES);
 354         for (i = 0; i < NUM_REGS; ++i)
 355                 if (reg2pcb[i+off] != -1)
 356                         supply_register(i, &((int *)&pcb)[reg2pcb[i+off]]);
 357         /*
 358          * If the RPB is valid for this thread/proc use the register values
 359          * contained there.
 360          */
 361         if (addr == rpbpcbaddr) {
 362                 off = 0;
 363                 for (i = 0; i < NUM_REGS; ++i)
 364                         if (reg2pcb[i+off] != -1)
 365                                 supply_register(i, &((int *)rpbaddr)[reg2pcb[i+off]]);
 366         }
 367 }
 368
 369 void
 370 setup_kernel_debugging()
 371 {
 372         struct stat stb;
 373         CORE_ADDR addr;
 374
 375         fstat(corechan, &stb);
 376         devmem = 0;
 377         if ((stb.st_mode & S_IFMT) == S_IFCHR && stb.st_rdev == makedev(2, 0))
 378                 devmem = 1;
 379
 380         /* XXX */
 381         if (lookup_misc_func("Sysmap") < 0)
 382                 kerneltype = OS_MACH;
 383         else
 384                 kerneltype = OS_BSD;
 385
 386         if (kerneltype == OS_BSD) {
 387                 int len, err = 0;
 388
 389                 /*
 390                  * Hash table and PDIR are equivalently mapped
 391                  */
 392                 nhtbl = kvread(ksym_lookup("nhtbl"));
 393                 if (nhtbl != ~0) {
 394                         len = nhtbl * sizeof(*htbl);
 395                         htbl = (struct hte *) malloc(len);
 396                         if (htbl) {
 397                                 addr = kvread(ksym_lookup("htbl"));
 398                                 if (physrd(addr, (char *)htbl, len))
 399                                         err++;
 400                         } else
 401                                 err++;
 402                 } else
 403                         err++;
 404                 npdir = kvread(ksym_lookup("npdir"));
 405                 if (npdir != ~0) {
 406                         len = npdir * sizeof(*pdir);
 407                         pdir = (struct pde *) malloc(len);
 408                         if (pdir) {
 409                                 addr = kvread(ksym_lookup("pdir"));
 410                                 if (physrd(addr, (char *)pdir, len))
 411                                         err++;
 412                         } else
 413                                 err++;
 414                 } else
 415                         err++;
 416                 if (err) {
 417                         error("cannot read PDIR/HTBL");
 418                         return;
 419                 }
 420                 vtophys_ready = 1;
 421
 422                 /*
 423                  * pcb where "panic" saved registers in first thing in
 424                  * current u-area.  The current u-area is pointed to by
 425                  * "uptr".
 426                  */
 427                 addr = kvread(ksym_lookup("uptr"));
 428                 if (addr == ~0) {
 429                         error("cannot read current u-area address");
 430                         return;
 431                 }
 432                 read_pcb(vtophys(0, addr));     /* XXX space */
 433                 if (!devmem) {
 434                         /* find stack frame */
 435                         CORE_ADDR panicstr;
 436                         char buf[256];
 437                         register char *cp;
 438
 439                         panicstr = kvread(ksym_lookup("panicstr"));
 440                         if (panicstr == ~0)
 441                                 return;
 442                         kernel_core_file_hook(panicstr, buf, sizeof(buf));
 443                         for (cp = buf; cp < &buf[sizeof(buf)] && *cp; cp++)
 444                                 if (!isascii(*cp) || (!isprint(*cp) && !isspace(*cp)))
 445                                         *cp = '?';
 446                         if (*cp)
 447                                 *cp = '\0';
 448                         printf("panic: %s\n", buf);
 449                 }
 450         }
 451 #ifdef MACHKERNELDEBUG
 452         else {
 453                 int *thread;
 454
 455                 /*
 456                  * Set up address translation
 457                  */
 458                 if (mach_vtophys_init() == 0) {
 459                         error("cannot initialize vtophys for Mach");
 460                         return;
 461                 }
 462                 vtophys_ready = 1;
 463
 464                 /*
 465                  * Locate active thread and read PCB
 466                  * XXX MAJOR HACK
 467                  *      - assumes uni-processor
 468                  *      - assumes position of pcb to avoid mach includes
 469                  */
 470                 thread = (int *)kvread(ksym_lookup("active_threads"));
 471                 addr = kvread(&thread[9]);              /* XXX: pcb addr */
 472                 read_pcb(vtophys(0, addr));
 473         }
 474 #endif
 475 }
 476
 477 vtop_command(arg)
 478         char *arg;
 479 {
 480         u_int sp, off, pa;
 481
 482         if (!arg)
 483                 error_no_arg("kernel virtual address");
 484         if (!kernel_debugging)
 485                 error("not debugging kernel");
 486
 487         sp = 0;         /* XXX */
 488         off = (u_int) parse_and_eval_address(arg);
 489         pa = vtophys(sp, off);
 490         printf("%lx.%lx -> ", sp, off);
 491         if (pa == ~0)
 492                 printf("<invalid>\n");
 493         else
 494                 printf("%lx\n", pa);
 495 }
 496
 497 set_paddr_command(arg)
 498         char *arg;
 499 {
 500         u_int addr;
 501
 502         if (!arg) {
 503                 if (kerneltype == OS_BSD)
 504                         error_no_arg("ps-style address for new process");
 505                 else
 506                         error_no_arg("thread structure virtual address");
 507         }
 508         if (!kernel_debugging)
 509                 error("not debugging kernel");
 510
 511         addr = (u_int) parse_and_eval_address(arg);
 512         if (kerneltype == OS_BSD)
 513                 addr = ctob(addr);
 514         else {
 515                 addr = kvread(&(((int *)addr)[9]));     /* XXX: pcb addr */
 516                 addr = vtophys(0, addr);                /* XXX space */
 517         }
 518         read_pcb(addr);
 519
 520         flush_cached_frames();
 521         set_current_frame(create_new_frame(read_register(FP_REGNUM), read_pc()));
 522         select_frame(get_current_frame(), 0);
 523 }
 524
 525 /*
 526  * read len bytes from kernel virtual address 'addr' into local
 527  * buffer 'buf'.  Return 0 if read ok, 1 otherwise.  On read
 528  * errors, portion of buffer not read is zeroed.
 529  */
 530 kernel_core_file_hook(addr, buf, len)
 531         CORE_ADDR addr;
 532         char *buf;
 533         int len;
 534 {
 535         int i;
 536         CORE_ADDR paddr;
 537
 538         while (len > 0) {
 539                 paddr = vtophys(0, addr);       /* XXX space */
 540                 if (paddr == ~0) {
 541                         bzero(buf, len);
 542                         return (1);
 543                 }
 544                 /* we can't read across a page boundary */
 545                 i = min(len, NBPG - (addr & PGOFSET));
 546                 if (physrd(paddr, buf, i)) {
 547                         bzero(buf, len);
 548                         return (1);
 549                 }
 550                 buf += i;
 551                 addr += i;
 552                 len -= i;
 553         }
 554         return (0);
 555 }
 556 #endif
 557
 558
 559 \f
 560
 561
 562 /* Routines to extract various sized constants out of hppa
 563    instructions. */
 564
 565 /* This assumes that no garbage lies outside of the lower bits of
 566    value. */
 567
 568 int
 569 sign_extend (val, bits)
 570      unsigned val, bits;
 571 {
 572   return (int)(val >> bits - 1 ? (-1 << bits) | val : val);
 573 }
 574
 575 /* For many immediate values the sign bit is the low bit! */
 576
 577 int
 578 low_sign_extend (val, bits)
 579      unsigned val, bits;
 580 {
 581   return (int)((val & 0x1 ? (-1 << (bits - 1)) : 0) | val >> 1);
 582 }
 583 /* extract the immediate field from a ld{bhw}s instruction */
 584
 585
 586
 587 unsigned
 588 get_field (val, from, to)
 589      unsigned val, from, to;
 590 {
 591   val = val >> 31 - to;
 592   return val & ((1 << 32 - from) - 1);
 593 }
 594
 595 unsigned
 596 set_field (val, from, to, new_val)
 597      unsigned *val, from, to;
 598 {
 599   unsigned mask = ~((1 << (to - from + 1)) << (31 - from));
 600   return *val = *val & mask | (new_val << (31 - from));
 601 }
 602
 603 /* extract a 3-bit space register number from a be, ble, mtsp or mfsp */
 604
 605 extract_3 (word)
 606      unsigned word;
 607 {
 608   return GET_FIELD (word, 18, 18) << 2 | GET_FIELD (word, 16, 17);
 609 }
 610
 611 extract_5_load (word)
 612      unsigned word;
 613 {
 614   return low_sign_extend (word >> 16 & MASK_5, 5);
 615 }
 616
 617 /* extract the immediate field from a st{bhw}s instruction */
 618
 619 int
 620 extract_5_store (word)
 621      unsigned word;
 622 {
 623   return low_sign_extend (word & MASK_5, 5);
 624 }
 625
 626 /* extract an 11 bit immediate field */
 627
 628 int
 629 extract_11 (word)
 630      unsigned word;
 631 {
 632   return low_sign_extend (word & MASK_11, 11);
 633 }
 634
 635 /* extract a 14 bit immediate field */
 636
 637 int
 638 extract_14 (word)
 639      unsigned word;
 640 {
 641   return low_sign_extend (word & MASK_14, 14);
 642 }
 643
 644 /* deposit a 14 bit constant in a word */
 645
 646 unsigned
 647 deposit_14 (opnd, word)
 648      int opnd;
 649      unsigned word;
 650 {
 651   unsigned sign = (opnd < 0 ? 1 : 0);
 652
 653   return word | ((unsigned)opnd << 1 & MASK_14)  | sign;
 654 }
 655
 656 /* extract a 21 bit constant */
 657
 658 int
 659 extract_21 (word)
 660      unsigned word;
 661 {
 662   int val;
 663
 664   word &= MASK_21;
 665   word <<= 11;
 666   val = GET_FIELD (word, 20, 20);
 667   val <<= 11;
 668   val |= GET_FIELD (word, 9, 19);
 669   val <<= 2;
 670   val |= GET_FIELD (word, 5, 6);
 671   val <<= 5;
 672   val |= GET_FIELD (word, 0, 4);
 673   val <<= 2;
 674   val |= GET_FIELD (word, 7, 8);
 675   return sign_extend (val, 21) << 11;
 676 }
 677
 678 /* deposit a 21 bit constant in a word. Although 21 bit constants are
 679    usually the top 21 bits of a 32 bit constant, we assume that only
 680    the low 21 bits of opnd are relevant */
 681
 682 unsigned
 683 deposit_21 (opnd, word)
 684      unsigned opnd, word;
 685 {
 686   unsigned val = 0;
 687
 688   val |= GET_FIELD (opnd, 11 + 14, 11 + 18);
 689   val <<= 2;
 690   val |= GET_FIELD (opnd, 11 + 12, 11 + 13);
 691   val <<= 2;
 692   val |= GET_FIELD (opnd, 11 + 19, 11 + 20);
 693   val <<= 11;
 694   val |= GET_FIELD (opnd, 11 + 1, 11 + 11);
 695   val <<= 1;
 696   val |= GET_FIELD (opnd, 11 + 0, 11 + 0);
 697   return word | val;
 698 }
 699
 700 /* extract a 12 bit constant from branch instructions */
 701
 702 int
 703 extract_12 (word)
 704      unsigned word;
 705 {
 706   return sign_extend (GET_FIELD (word, 19, 28) |
 707                       GET_FIELD (word, 29, 29) << 10 |
 708                       (word & 0x1) << 11, 12) << 2;
 709 }
 710
 711 /* extract a 17 bit constant from branch instructions, returning the
 712    19 bit signed value. */
 713
 714 int
 715 extract_17 (word)
 716      unsigned word;
 717 {
 718   return sign_extend (GET_FIELD (word, 19, 28) |
 719                       GET_FIELD (word, 29, 29) << 10 |
 720                       GET_FIELD (word, 11, 15) << 11 |
 721                       (word & 0x1) << 16, 17) << 2;
 722 }
 723
 724
 725 CORE_ADDR
 726 frame_saved_pc (frame)
 727      FRAME frame;
 728 {
 729   if (get_current_frame () == frame)
 730     {
 731       struct frame_saved_regs saved_regs;
 732
 733       get_frame_saved_regs (frame, &saved_regs);
 734       if (saved_regs.regs[RP_REGNUM])
 735         return read_memory_integer (saved_regs.regs[RP_REGNUM], 4);
 736       else
 737         return read_register (RP_REGNUM);
 738     }
 739   return read_memory_integer (frame->frame - 20, 4) & ~0x3;
 740 }
 741
 742 /* To see if a frame chain is valid, see if the caller looks like it
 743    was compiled with gcc. */
 744
 745 int frame_chain_valid (chain, thisframe)
 746      FRAME_ADDR chain;
 747      FRAME thisframe;
 748 {
 749   if (chain && (chain > 0x60000000
 750                 /* || remote_debugging   -this is no longer used */
 751 #ifdef KERNELDEBUG
 752                 || kernel_debugging
 753 #endif
 754                 ))
 755     {
 756       CORE_ADDR pc = get_pc_function_start (FRAME_SAVED_PC (thisframe));
 757
 758       if (!inside_entry_file (pc))
 759         return 0;
 760       /* look for stw rp, -20(0,sp); copy 4,1; copy sp, 4 */
 761       if (read_memory_integer (pc, 4) == 0x6BC23FD9)
 762         pc = pc + 4;
 763
 764       if (read_memory_integer (pc, 4) == 0x8040241 &&
 765           read_memory_integer (pc + 4, 4) == 0x81E0244)
 766         return 1;
 767       else
 768         return 0;
 769     }
 770   else
 771     return 0;
 772 }
 773
 774 /* Some helper functions. gcc_p returns 1 if the function beginning at
 775    pc appears to have been compiled with gcc. hpux_cc_p returns 1 if
 776    fn was compiled with hpux cc. gcc functions look like :
 777
 778    stw     rp,-0x14(sp) ; optional
 779    or      r4,r0,r1
 780    or      sp,r0,r4
 781    stwm    r1,framesize(sp)
 782
 783    hpux cc functions look like:
 784
 785    stw     rp,-0x14(sp) ; optional.
 786    stwm    r3,framesiz(sp)
 787    */
 788
 789 gcc_p (pc)
 790      CORE_ADDR pc;
 791 {
 792   if (read_memory_integer (pc, 4) == 0x6BC23FD9)
 793     pc = pc + 4;
 794
 795   if (read_memory_integer (pc, 4) == 0x8040241 &&
 796       read_memory_integer (pc + 4, 4) == 0x81E0244)
 797     return 1;
 798   return 0;
 799 }
 800
 801
 802 find_dummy_frame_regs (frame, frame_saved_regs)
 803      struct frame_info *frame;
 804      struct frame_saved_regs *frame_saved_regs;
 805 {
 806   CORE_ADDR fp = frame->frame;
 807   int i;
 808
 809   frame_saved_regs->regs[RP_REGNUM] = fp - 20 & ~0x3;
 810   frame_saved_regs->regs[FP_REGNUM] = fp;
 811   frame_saved_regs->regs[1] = fp + 8;
 812   frame_saved_regs->regs[3] = fp + 12;
 813   for (fp += 16, i = 3; i < 30; fp += 4, i++)
 814     frame_saved_regs->regs[i] = fp;
 815   frame_saved_regs->regs[31] = fp;
 816   fp += 4;
 817   for (i = FP0_REGNUM; i < NUM_REGS; i++, fp += 8)
 818     frame_saved_regs->regs[i] = fp;
 819   /* depend on last increment of fp */
 820   frame_saved_regs->regs[IPSW_REGNUM] = fp - 4;
 821   frame_saved_regs->regs[SAR_REGNUM] = fp;
 822   fp += 4;
 823   frame_saved_regs->regs[PCOQ_TAIL_REGNUM] = fp;
 824   frame_saved_regs->regs[PCSQ_TAIL_REGNUM] = fp;
 825 }
 826
 827 CORE_ADDR
 828 hp_push_arguments (nargs, args, sp, struct_return, struct_addr)
 829      int nargs;
 830      value *args;
 831      CORE_ADDR sp;
 832      int struct_return;
 833      CORE_ADDR struct_addr;
 834 {
 835   /* array of arguments' offsets */
 836   int *offset = (int *)alloca(nargs);
 837   int cum = 0;
 838   int i, alignment;
 839
 840   for (i = 0; i < nargs; i++)
 841     {
 842       cum += TYPE_LENGTH (VALUE_TYPE (args[i]));
 843       /* value must go at proper alignment. Assume alignment is a
 844          power of two.*/
 845       alignment = hp_alignof (VALUE_TYPE (args[i]));
 846       if (cum % alignment)
 847         cum = (cum + alignment) & -alignment;
 848       offset[i] = -cum;
 849     }
 850   for (i == 0; i < nargs; i++)
 851     {
 852       write_memory (sp + offset[i], VALUE_CONTENTS (args[i]), sizeof(int));
 853     }
 854   sp += min ((cum + 7) & -8, 48);
 855   if (struct_return)
 856     write_register (28, struct_addr);
 857   return sp + 48;
 858 }
 859
 860 /* return the alignment of a type in bytes. Structures have the maximum
 861    alignment required by their fields. */
 862
 863 int
 864 hp_alignof (arg)
 865      struct type *arg;
 866 {
 867   int max_align, align, i;
 868   switch (TYPE_CODE (arg))
 869     {
 870     case TYPE_CODE_PTR:
 871     case TYPE_CODE_INT:
 872     case TYPE_CODE_FLT:
 873       return TYPE_LENGTH (arg);
 874     case TYPE_CODE_ARRAY:
 875       return hp_alignof (TYPE_FIELD_TYPE (arg, 0));
 876     case TYPE_CODE_STRUCT:
 877     case TYPE_CODE_UNION:
 878       max_align = 2;
 879       for (i = 0; i < TYPE_NFIELDS (arg); i++)
 880         {
 881           /* Bit fields have no real alignment. */
 882           if (!TYPE_FIELD_BITPOS (arg, i))
 883             {
 884               align = hp_alignof (TYPE_FIELD_TYPE (arg, i));
 885               max_align = max (max_align, align);
 886             }
 887         }
 888       return max_align;
 889     default:
 890       return 4;
 891     }
 892 }
 893
 894 /* Print the register regnum, or all registers if regnum is -1 */
 895
 896 pa_do_registers_info (regnum, fpregs)
 897      int regnum;
 898      int fpregs;
 899 {
 900   char raw_regs [REGISTER_BYTES];
 901   int i;
 902
 903   for (i = 0; i < NUM_REGS; i++)
 904     read_relative_register_raw_bytes (i, raw_regs + REGISTER_BYTE (i));
 905   if (regnum = -1)
 906     pa_print_registers (raw_regs, regnum);
 907   else if (regnum < FP0_REGNUM)
 908     {
 909       printf ("%s %x\n", reg_names[regnum], *(long *)(raw_regs +
 910                                                       REGISTER_BYTE (regnum)));
 911     }
 912   else
 913     pa_print_fp_reg (regnum);
 914 }
 915
 916 pa_print_registers (raw_regs, regnum)
 917      char *raw_regs;
 918      int regnum;
 919 {
 920   int i;
 921
 922   for (i = 0; i < 18; i++)
 923     printf ("%8.8s: %8x  %8.8s: %8x  %8.8s: %8x  %8.8s: %8x\n",
 924                      reg_names[i],
 925                      *(int *)(raw_regs + REGISTER_BYTE (i)),
 926                      reg_names[i + 18],
 927                      *(int *)(raw_regs + REGISTER_BYTE (i + 18)),
 928                      reg_names[i + 36],
 929                      *(int *)(raw_regs + REGISTER_BYTE (i + 36)),
 930                      reg_names[i + 54],
 931                      *(int *)(raw_regs + REGISTER_BYTE (i + 54)));
 932   for (i = 72; i < NUM_REGS; i++)
 933     pa_print_fp_reg (i);
 934 }
 935
 936 pa_print_fp_reg (i)
 937      int i;
 938 {
 939   unsigned char raw_buffer[MAX_REGISTER_RAW_SIZE];
 940   unsigned char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE];
 941   REGISTER_TYPE val;
 942
 943   /* Get the data in raw format, then convert also to virtual format.  */
 944   read_relative_register_raw_bytes (i, raw_buffer);
 945   REGISTER_CONVERT_TO_VIRTUAL (i, raw_buffer, virtual_buffer);
 946
 947   fputs_filtered (reg_names[i], stdout);
 948   print_spaces_filtered (15 - strlen (reg_names[i]), stdout);
 949
 950   val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, stdout, 0,
 951              1, 0, Val_pretty_default);
 952   printf_filtered ("\n");
 953
 954 }
 955
 956 /*
 957  * Virtual to physical translation routines for Utah's Mach 3.0
 958  */
 959 #ifdef MACHKERNELDEBUG
 960
 961 #define STATIC
 962
 963 #if 0   /* too many includes to resolve, too much crap */
 964 #include <kern/queue.h>
 965 #include <vm/pmap.h>
 966 #include <mach/vm_prot.h>
 967 #else
 968 /* queue.h */
 969 struct queue_entry {
 970         struct queue_entry      *next;          /* next element */
 971         struct queue_entry      *prev;          /* previous element */
 972 };
 973
 974 typedef struct queue_entry      *queue_t;
 975 typedef struct queue_entry      queue_head_t;
 976 typedef struct queue_entry      queue_chain_t;
 977 typedef struct queue_entry      *queue_entry_t;
 978
 979 /* pmap.h */
 980 #define HP800_HASHSIZE          1024
 981 #define HP800_HASHSIZE_LOG2     10
 982
 983 #define pmap_hash(space, offset) \
 984         (((unsigned) (space) << 5 ^ \
 985           ((unsigned) (offset) >> 19 | (unsigned) (space) << 13) ^ \
 986           (unsigned) (offset) >> 11) & (HP800_HASHSIZE-1))
 987
 988 struct mapping {
 989         queue_head_t    hash_link;      /* hash table links */
 990         queue_head_t    phys_link;      /* for mappings of a given PA */
 991         space_t         space;          /* virtual space */
 992         unsigned        offset;         /* virtual page number */
 993         unsigned        tlbpage;        /* physical page (for TLB load) */
 994         unsigned        tlbprot;        /* prot/access rights (for TLB load) */
 995         struct pmap     *pmap;          /* pmap mapping belongs to */
 996 };
 997
 998 struct phys_entry {
 999         queue_head_t    phys_link;      /* head of mappings of a given PA */
1000         struct mapping  *writer;        /* mapping with R/W access */
1001         unsigned        tlbprot;        /* TLB format protection */
1002 };
1003
1004 #endif
1005
1006 #define atop(a)         ((unsigned)(a) >> 11)
1007 #define ptoa(p)         ((unsigned)(p) << 11)
1008 #define trunc_page(a)   ((unsigned)(a) & ~2047)
1009
1010 STATIC long equiv_end;
1011 STATIC queue_head_t *Ovtop_table, *vtop_table, *Ofree_mapping, free_mapping;
1012 STATIC struct phys_entry *Ophys_table, *phys_table;
1013 STATIC long vm_last_phys, vm_first_phys;
1014 STATIC struct mapping *firstmap, *lastmap, *Omap_table, *map_table;
1015 STATIC unsigned Omlow, Omhigh, Omhead, Ovlow, Ovhigh, Oplow, Ophigh;
1016 STATIC unsigned mlow, mhigh, mhead, vlow, vhigh, plow, phigh;
1017 STATIC int vtopsize, physsize, mapsize;
1018 STATIC int kmemfd;
1019
1020 #define IS_OVTOPPTR(p)  ((unsigned)(p) >= Ovlow && (unsigned)(p) < Ovhigh)
1021 #define IS_OMAPPTR(p)   ((unsigned)(p) >= Omlow && (unsigned)(p) < Omhigh)
1022 #define IS_OPHYSPTR(p)  ((unsigned)(p) >= Oplow && (unsigned)(p) < Ophigh)
1023 #define IS_VTOPPTR(p)   ((unsigned)(p) >= vlow && (unsigned)(p) < vhigh)
1024 #define IS_MAPPTR(p)    ((unsigned)(p) >= mlow && (unsigned)(p) < mhigh)
1025 #define IS_PHYSPTR(p)   ((unsigned)(p) >= plow && (unsigned)(p) < phigh)
1026
1027 struct mapstate {
1028         char    unused;
1029         char    flags;
1030         short   hashix;
1031         short   physix;
1032 } *mapstate;
1033
1034 /* flags */
1035 #define M_ISFREE        1
1036 #define M_ISHASH        2
1037 #define M_ISPHYS        4
1038
1039 mach_vtophys_init()
1040 {
1041         int errors = 0;
1042
1043         if (!readdata())
1044                 errors++;
1045         if (!verifydata())
1046                 errors++;
1047         if (!errors)
1048                 return(1);
1049         fflush(stdout);
1050         fprintf(stderr,
1051                 "translate: may not be able to translate all addresses\n");
1052         return(0);
1053 }
1054
1055 mach_vtophys(space, off, pa)
1056         unsigned space, off, *pa;
1057 {
1058         register int i;
1059         register queue_t qp;
1060         register struct mapping *mp;
1061         int poff;
1062
1063         /*
1064          * Kernel IO or equivilently mapped, one to one.
1065          */
1066         if (space == 0 && (long)off < equiv_end) {
1067                 *pa = off;
1068                 return(1);
1069         }
1070         /*
1071          * Else look it up in specified space
1072          */
1073         poff = off - trunc_page(off);
1074         off = trunc_page(off);
1075         qp = &vtop_table[pmap_hash(space, off)];
1076         for (mp = (struct mapping *)qp->next;
1077              qp != (queue_entry_t)mp;
1078              mp = (struct mapping *)mp->hash_link.next) {
1079                 if (mp->space == space && mp->offset == off) {
1080                         *pa = (mp->tlbpage << 7) | poff;
1081                         return(1);
1082                 }
1083         }
1084         return(0);
1085 }
1086
1087 STATIC
1088 readdata()
1089 {
1090         char *tmp, *mach_malloc();
1091         long size;
1092
1093         /* easy scalars */
1094         mach_read("equiv_end", ~0, (char *)&equiv_end, sizeof equiv_end);
1095         mach_read("vm_first_phys", ~0,
1096                   (char *)&vm_first_phys, sizeof vm_first_phys);
1097         mach_read("vm_last_phys", ~0,
1098                   (char *)&vm_last_phys, sizeof vm_last_phys);
1099         mach_read("firstmap", ~0, (char *)&firstmap, sizeof firstmap);
1100         mach_read("lastmap", ~0, (char *)&lastmap, sizeof lastmap);
1101
1102         /* virtual to physical hash table */
1103         vtopsize = HP800_HASHSIZE;
1104         size = vtopsize * sizeof(queue_head_t);
1105         tmp = mach_malloc("vtop table", size);
1106         mach_read("vtop_table", ~0, (char *)&Ovtop_table, sizeof Ovtop_table);
1107         mach_read("vtop table", (CORE_ADDR)Ovtop_table, tmp, size);
1108         vtop_table = (queue_head_t *) tmp;
1109
1110         /* inverted page table */
1111         physsize = atop(vm_last_phys - vm_first_phys);
1112         size = physsize * sizeof(struct phys_entry);
1113         tmp = mach_malloc("phys table", size);
1114         mach_read("phys_table", ~0, (char *)&Ophys_table, sizeof Ophys_table);
1115         mach_read("phys table", (CORE_ADDR)Ophys_table, tmp, size);
1116         phys_table = (struct phys_entry *) tmp;
1117
1118         /* mapping structures */
1119         Ofree_mapping = (queue_head_t *) ksym_lookup("free_mapping");
1120         mach_read("free mapping", (CORE_ADDR)Ofree_mapping,
1121                   (char *) &free_mapping, sizeof free_mapping);
1122         Omap_table = firstmap;
1123         mapsize = lastmap - firstmap;
1124         size = mapsize * sizeof(struct mapping);
1125         tmp = mach_malloc("mapping table", size);
1126         mach_read("mapping table", (CORE_ADDR)Omap_table, tmp, size);
1127         map_table = (struct mapping *) tmp;
1128
1129         /* set limits */
1130         Ovlow = (unsigned) Ovtop_table;
1131         Ovhigh = (unsigned) &Ovtop_table[vtopsize];
1132         Oplow = (unsigned) Ophys_table;
1133         Ophigh = (unsigned) &Ophys_table[physsize];
1134         Omhead = (unsigned) Ofree_mapping;
1135         Omlow = (unsigned) firstmap;
1136         Omhigh = (unsigned) lastmap;
1137         mlow = (unsigned) map_table;
1138         mhigh = (unsigned) &map_table[mapsize];
1139         mhead = (unsigned) &free_mapping;
1140         vlow = (unsigned) vtop_table;
1141         vhigh = (unsigned) &vtop_table[vtopsize];
1142         plow = (unsigned) phys_table;
1143         phigh = (unsigned) &phys_table[physsize];
1144
1145 #if 0
1146         fprintf(stderr, "Ovtop [%#x-%#x) Ophys [%#x-%#x) Omap %#x [%#x-%#x)\n",
1147                 Ovlow, Ovhigh, Oplow, Ophigh, Omhead, Omlow, Omhigh);
1148         fprintf(stderr, "vtop [%#x-%#x) phys [%#x-%#x) map %#x [%#x-%#x)\n",
1149                 vlow, vhigh, plow, phigh, mhead, mlow, mhigh);
1150 #endif
1151         return(adjustdata());
1152 }
1153
1154 STATIC unsigned
1155 ptrcvt(ptr)
1156         unsigned ptr;
1157 {
1158         unsigned ret;
1159         char *str;
1160
1161         if (ptr == 0) {
1162                 ret = ptr;
1163                 str = "null";
1164         } else if (IS_OVTOPPTR(ptr)) {
1165                 ret = vlow + (ptr - Ovlow);
1166                 str = "vtop";
1167         } else if (IS_OPHYSPTR(ptr)) {
1168                 ret = plow + (ptr - Oplow);
1169                 str = "phys";
1170         } else if (IS_OMAPPTR(ptr)) {
1171                 ret = mlow + (ptr - Omlow);
1172                 str = "map";
1173         } else if (ptr == Omhead) {
1174                 ret = mhead;
1175                 str = "maphead";
1176         } else {
1177                 error("bogus pointer %#x", ptr);
1178                 str = "wild";
1179                 ret = ptr;
1180         }
1181 #if 0
1182         fprintf(stderr, "%x (%s) -> %x\n", ptr, str, ret);
1183 #endif
1184         return(ret);
1185 }
1186
1187 STATIC int
1188 adjustdata()
1189 {
1190         register int i, lim;
1191         queue_head_t *nq;
1192         struct phys_entry *np;
1193         struct mapping *nm;
1194
1195         /* hash table */
1196         lim = vtopsize;
1197         for (nq = vtop_table; nq < &vtop_table[lim]; nq++) {
1198                 nq->next = (queue_entry_t) ptrcvt((unsigned)nq->next);
1199                 nq->prev = (queue_entry_t) ptrcvt((unsigned)nq->prev);
1200         }
1201
1202         /* IPT */
1203         lim = physsize;
1204         for (np = phys_table; np < &phys_table[lim]; np++) {
1205                 np->phys_link.next = (queue_entry_t)
1206                         ptrcvt((unsigned)np->phys_link.next);
1207                 np->phys_link.prev = (queue_entry_t)
1208                         ptrcvt((unsigned)np->phys_link.prev);
1209                 np->writer = (struct mapping *) ptrcvt((unsigned)np->writer);
1210         }
1211
1212         /* mapping table */
1213         free_mapping.next = (queue_entry_t)ptrcvt((unsigned)free_mapping.next);
1214         free_mapping.prev = (queue_entry_t)ptrcvt((unsigned)free_mapping.prev);
1215         lim = mapsize;
1216         for (nm = map_table; nm < &map_table[lim]; nm++) {
1217                 nm->hash_link.next = (queue_entry_t)
1218                         ptrcvt((unsigned)nm->hash_link.next);
1219                 nm->hash_link.prev = (queue_entry_t)
1220                         ptrcvt((unsigned)nm->hash_link.prev);
1221                 nm->phys_link.next = (queue_entry_t)
1222                         ptrcvt((unsigned)nm->phys_link.next);
1223                 nm->phys_link.prev = (queue_entry_t)
1224                         ptrcvt((unsigned)nm->phys_link.prev);
1225         }
1226         return(1);
1227 }
1228
1229 /*
1230  * Consistency checks, make sure:
1231  *
1232  *      1. all mappings are accounted for
1233  *      2. no cycles
1234  *      3. no wild pointers
1235  *      4. consisent TLB state
1236  */
1237 STATIC int
1238 verifydata()
1239 {
1240         register struct mapstate *ms;
1241         register int i;
1242         int errors = 0;
1243
1244         mapstate = (struct mapstate *)
1245                 mach_malloc("map state", mapsize * sizeof(struct mapstate));
1246         for (ms = mapstate; ms < &mapstate[mapsize]; ms++) {
1247                 ms->flags = 0;
1248                 ms->hashix = ms->physix = -2;
1249         }
1250
1251         /*
1252          * Check the free list
1253          */
1254         checkhashchain(&free_mapping, M_ISFREE, -1);
1255         /*
1256          * Check every hash chain
1257          */
1258         for (i = 0; i < vtopsize; i++)
1259                 checkhashchain(&vtop_table[i], M_ISHASH, i);
1260         /*
1261          * Check every phys chain
1262          */
1263         for (i = 0; i < physsize; i++)
1264                 checkphyschain(&phys_table[i].phys_link, M_ISPHYS, i);
1265         /*
1266          * Cycle through mapstate looking for anomolies
1267          */
1268         ms = mapstate;
1269         for (i = 0; i < mapsize; i++) {
1270                 switch (ms->flags) {
1271                 case M_ISFREE:
1272                 case M_ISHASH|M_ISPHYS:
1273                         break;
1274                 case 0:
1275                         merror(ms, "not found");
1276                         errors++;
1277                         break;
1278                 case M_ISHASH:
1279                         merror(ms, "in vtop but not phys");
1280                         errors++;
1281                         break;
1282                 case M_ISPHYS:
1283                         merror(ms, "in phys but not vtop");
1284                         errors++;
1285                         break;
1286                 default:
1287                         merror(ms, "totally bogus");
1288                         errors++;
1289                         break;
1290                 }
1291                 ms++;
1292         }
1293         return(errors ? 0 : 1);
1294 }
1295
1296 STATIC void
1297 checkhashchain(qhp, flag, ix)
1298         queue_entry_t qhp;
1299 {
1300         register queue_entry_t qp, pqp;
1301         register struct mapping *mp;
1302         struct mapstate *ms;
1303
1304         qp = qhp->next;
1305         /*
1306          * First element is not a mapping structure,
1307          * chain must be empty.
1308          */
1309         if (!IS_MAPPTR(qp)) {
1310                 if (qp != qhp || qp != qhp->prev)
1311                         fatal("bad vtop_table header pointer");
1312         } else {
1313                 pqp = qhp;
1314                 do {
1315                         mp = (struct mapping *) qp;
1316                         qp = &mp->hash_link;
1317                         if (qp->prev != pqp)
1318                                 fatal("bad hash_link prev pointer");
1319                         ms = &mapstate[mp-map_table];
1320                         ms->flags |= flag;
1321                         ms->hashix = ix;
1322                         pqp = (queue_entry_t) mp;
1323                         qp = qp->next;
1324                 } while (IS_MAPPTR(qp));
1325                 if (qp != qhp)
1326                         fatal("bad hash_link next pointer");
1327         }
1328 }
1329
1330 STATIC void
1331 checkphyschain(qhp, flag, ix)
1332         queue_entry_t qhp;
1333 {
1334         register queue_entry_t qp, pqp;
1335         register struct mapping *mp;
1336         struct mapstate *ms;
1337
1338         qp = qhp->next;
1339         /*
1340          * First element is not a mapping structure,
1341          * chain must be empty.
1342          */
1343         if (!IS_MAPPTR(qp)) {
1344                 if (qp != qhp || qp != qhp->prev)
1345                         fatal("bad phys_table header pointer");
1346         } else {
1347                 pqp = qhp;
1348                 do {
1349                         mp = (struct mapping *) qp;
1350                         qp = &mp->phys_link;
1351                         if (qp->prev != pqp)
1352                                 fatal("bad phys_link prev pointer");
1353                         ms = &mapstate[mp-map_table];
1354                         ms->flags |= flag;
1355                         ms->physix = ix;
1356                         pqp = (queue_entry_t) mp;
1357                         qp = qp->next;
1358                 } while (IS_MAPPTR(qp));
1359                 if (qp != qhp)
1360                         fatal("bad phys_link next pointer");
1361         }
1362 }
1363
1364 STATIC void
1365 merror(ms, str)
1366         struct mapstate *ms;
1367         char *str;
1368 {
1369         terminal_ours();
1370         fflush(stdout);
1371         fprintf(stderr,
1372                 "vtophys: %s: %c%c%c, hashix %d, physix %d, mapping %x\n",
1373                 str,
1374                 (ms->flags & M_ISFREE) ? 'F' : '-',
1375                 (ms->flags & M_ISHASH) ? 'H' : '-',
1376                 (ms->flags & M_ISPHYS) ? 'P' : '-',
1377                 ms->hashix, ms->physix, &map_table[ms-mapstate]);
1378         return_to_top_level();
1379 }
1380
1381 STATIC int
1382 mach_read(str, from, top, size)
1383         char *str;
1384         CORE_ADDR from;
1385         char *top;
1386         int size;
1387 {
1388         CORE_ADDR paddr;
1389
1390         if (from == ~0)
1391                 from = ksym_lookup(str);
1392         paddr = vtophys(0, from);
1393         if (paddr == ~0 || physrd(paddr, top, size) != 0)
1394                 fatal("cannot read %s", str);
1395 }
1396
1397 STATIC char *
1398 mach_malloc(str, size)
1399         char *str;
1400         int size;
1401 {
1402         char *ptr = (char *) malloc(size);
1403
1404         if (ptr == 0)
1405                 fatal("no memory for %s", str);
1406         return(ptr);
1407 }
1408 #endif
1409
1410 #ifdef KERNELDEBUG
1411 void
1412 _initialize_hp9k8_dep()
1413 {
1414         add_com ("process-address", class_obscure, set_paddr_command,
1415 "The process identified by (ps-style) ADDR becomes the\n\
1416 \"current\" process context for kernel debugging.");
1417         add_com_alias ("paddr", "process-address", class_obscure, 0);
1418         add_com ("virtual-to-physical", class_obscure, vtop_command,
1419 "Translates the kernel virtual address ADDR into a physical address.");
1420         add_com_alias ("vtop", "virtual-to-physical", class_obscure, 0);
1421 }
1422 #endif