home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 1 / 1288 / gdb-x386.02
Encoding:
Text File  |  1990-12-28  |  47.3 KB  |  1,764 lines
  1. *** dist-gdb.old/x386dbx.c    Thu Jan  1 00:00:00 1970
  2. --- x386dbx.c    Sat May  5 14:59:45 1990
  3. ***************
  4. *** 0 ****
  5. --- 1,478 ----
  6. + #include <stdio.h>
  7. + #include <a.out.h>
  8. + #include <fcntl.h>
  9. + #include <sys/types.h>
  10. + #include <sys/relsym.h>
  11. + #include <sys/param.h>
  12. + #include <sys/file.h>
  13. + #include "defs.h"
  14. + #include "param.h"
  15. + #include "symtab.h"
  16. + #include "gas-nlist.h"
  17. + 
  18. + 
  19. + /* XENIX symbol segment shape definitions */
  20. + 
  21. + struct section2 {            /* File info table shape */
  22. +     short        segment;    /* segment number */
  23. +     CORE_ADDR    address;    /* start address for this file */
  24. +     unsigned short    textsize;    /* size of the text for this file */
  25. +     long        type3off;    /* offset to type3 records, psym tab */
  26. +     long        type4off;    /* offset to type4 records, nlist tab */
  27. +     long        type5off;    /* offset to type5 records, str tab */
  28. +     long        type6off;    /* offset to type6 records */
  29. +     unsigned short    type3sz;    /* size of type3 records */
  30. +     unsigned short    type4sz;    /* size of type4 records */
  31. +     unsigned short    type5sz;    /* size of type5 records */
  32. +     unsigned short    type6sz;    /* size of type6 records */
  33. +     char        filelen;    /* length of filename */
  34. + };
  35. + 
  36. + /* psymtable (attribute 3) symbol segment shape */
  37. + 
  38. + struct psymbol_seg {
  39. +     long        address;    /* core address */
  40. +     short        segid;        /* segment number */
  41. +     short        typeid;        /* variable's type */
  42. +     char        varlen;        /* variable's length */
  43. + /*    char        name[0];    trailing name varlen long */
  44. + } record3;
  45. + 
  46. + /*  Info maintenance structures */
  47. + 
  48. + struct fileinfo {        /* per file info */
  49. +     CORE_ADDR    address;    /* start address for this file */
  50. +     unsigned short    textsize;    /* size of text for this file */
  51. +     long        psymoff;    /* psyms table */
  52. +     long        strtaboff;    /* string table aka $$TYPES */
  53. +     long        ntaboff;    /* nlist table aka $$SYMBOLS */
  54. +     unsigned short    psymsz;        /* size of psyms table */
  55. +     unsigned short    strtabsz;    /* size of string table */
  56. +     unsigned short    ntabsz;        /* size of nlist table */
  57. +     int        mscdebuginfo;    /* compiled with cc -g not gcc -g */
  58. +     char        *filename;    /* name of this file */
  59. +     struct fileinfo *next;
  60. + };
  61. + 
  62. + static struct fileinfo *fi_table = 0;
  63. + struct xseg *seg_table;
  64. + long num_seg_table_entries;
  65. + 
  66. + #ifdef __GNUC__
  67. + #define alloca __builtin_alloca
  68. + #endif
  69. + 
  70. + #define IGNORE_ATTR (-1)
  71. + 
  72. + static read_fileinfo_table(fp, segsize, name)
  73. + FILE *fp;
  74. + int segsize;
  75. + char *name;
  76. + {
  77. +   extern char *strrchr(), *xmalloc();
  78. +   char *fi_name;
  79. +   char *filename;
  80. +   struct section2 fi_entry;
  81. +   struct fileinfo *fi;
  82. + 
  83. +   fi_table = fi = (struct fileinfo *)xmalloc(sizeof(struct fileinfo));
  84. +   while (segsize > 0)
  85. +   {
  86. +     if ((fread((char *)&fi_entry.segment, sizeof(short), 1, fp) != 1)
  87. +       || (fread((char *)&fi_entry.address, sizeof(CORE_ADDR), 1, fp) != 1)
  88. +       || (fread((char *)&fi_entry.textsize, sizeof(unsigned short),1,fp) != 1)
  89. +       || (fread((char *)&fi_entry.type3off, sizeof(long), 1, fp) != 1)
  90. +       || (fread((char *)&fi_entry.type4off, sizeof(long), 1, fp) != 1)
  91. +       || (fread((char *)&fi_entry.type5off, sizeof(long), 1, fp) != 1)
  92. +       || (fread((char *)&fi_entry.type6off, sizeof(long), 1, fp) != 1)
  93. +       || (fread((char *)&fi_entry.type3sz, sizeof(unsigned short),1,fp) != 1)
  94. +       || (fread((char *)&fi_entry.type4sz, sizeof(unsigned short),1,fp) != 1)
  95. +       || (fread((char *)&fi_entry.type5sz, sizeof(unsigned short),1,fp) != 1)
  96. +       || (fread((char *)&fi_entry.type6sz, sizeof(unsigned short),1,fp) != 1)
  97. +       || (fread((char *)&fi_entry.filelen, sizeof(char), 1, fp) != 1))
  98. +       perror_with_name(name);
  99. + 
  100. +     segsize -= sizeof(short) + sizeof(CORE_ADDR) + 5 * sizeof(unsigned short)
  101. +            + 4 * sizeof(long) + sizeof(char);
  102. + 
  103. +     fi_name = alloca(fi_entry.filelen + 1);
  104. +     if (fread(fi_name, fi_entry.filelen, 1, fp) != 1)
  105. +       perror_with_name(name);
  106. +     fi_name[fi_entry.filelen] = '\0';
  107. +     segsize -= fi_entry.filelen;
  108. + 
  109. +     if ((filename = strrchr(fi_name, '/')) != (char *)0)
  110. +       fi_name = filename + 1;
  111. + 
  112. +     if ((filename = strrchr(fi_name, '(')) != (char *)0)
  113. +       fi_name = filename + 1;
  114. + 
  115. +     if ((filename = strrchr(fi_name, ')')) != (char *)0)
  116. +         *filename = '\0';
  117. +    
  118. +     {
  119. +       int len = strlen(fi_name);
  120. + 
  121. +       if (len > 2 && fi_name[len - 1] == 'o' && fi_name[len - 2] == '.')
  122. +       fi_name[len - 1] = 'c';
  123. +     }
  124. + 
  125. +     fi_name = savestring(fi_name, strlen(fi_name) + 1);
  126. + 
  127. +     fi->next = (struct fileinfo *)xmalloc(sizeof(struct fileinfo));
  128. +     fi = fi->next;
  129. + 
  130. +     fi->address = fi_entry.address;
  131. +     fi->textsize = fi_entry.textsize;
  132. +     fi->psymoff = fi_entry.type3off;
  133. +     fi->psymsz = fi_entry.type3sz;
  134. +     fi->strtaboff = fi_entry.type4off;
  135. +     fi->strtabsz = fi_entry.type4sz;
  136. +     fi->ntaboff = fi_entry.type5off;
  137. +     fi->ntabsz = fi_entry.type5sz;
  138. +     fi->mscdebuginfo = (fi_entry.type6sz != 0);
  139. +     fi->filename = fi_name;
  140. +   }
  141. +   fi->next = 0;  fi = fi_table;  fi_table = fi_table->next;  free(fi);
  142. + 
  143. + #ifdef X_DEBUG
  144. +     printf("\naddress   textsz  symoff   symsz  stroff   strsz  taboff   tabsz  name\n\n");
  145. +   for (fi = fi_table; fi != 0; fi = fi->next)
  146. +   {
  147. +     printf("% 8x  % 6d  % 6d  % 6d  % 6d  % 6d  % 6d  %6d  %s\n", fi->address, fi->textsize, fi->psymoff, fi->psymsz, fi->strtaboff, fi->strtabsz, fi->ntaboff, fi->ntabsz, fi->filename);
  148. +   }
  149. +   printf("\n");
  150. + #endif /* X_DEBUG */
  151. + }
  152. + 
  153. + static read_seg_table(fp, pos, size, name)
  154. + FILE *fp;
  155. + long pos, size;
  156. + {
  157. +   seg_table = (struct xseg *) xmalloc(size);
  158. +   fseek(fp, pos, 0);
  159. +   if (fread((char *)seg_table, size, 1, fp) != 1)
  160. +     perror_with_name(name);
  161. +   num_seg_table_entries = size / sizeof (struct xseg);
  162. + }
  163. + 
  164. + 
  165. + struct xseg *find_segment(type, attr)
  166. + int type, attr;
  167. + {
  168. +   struct xseg *cseg;
  169. + 
  170. +   for (cseg = seg_table; cseg < seg_table + num_seg_table_entries; ++cseg)
  171. +   if (cseg->xs_type == type &&
  172. +     (attr == IGNORE_ATTR || attr == cseg->xs_attr))
  173. +     return cseg;
  174. +   return NULL;
  175. + }
  176. + 
  177. + static int compare_misc_functions (fn1, fn2)
  178. + struct misc_function *fn1, *fn2;
  179. + {
  180. +   /* Return a signed result based on unsigned comparisons
  181. +      so that we sort into unsigned numeric order.  */
  182. + 
  183. +   if (fn1->address < fn2->address)
  184. +     return -1;
  185. +   if (fn1->address > fn2->address)
  186. +     return 1;
  187. +   return 0;
  188. + }
  189. + 
  190. + static int read_misc_functions(fp, segsize, name)
  191. + FILE *fp;
  192. + int segsize;
  193. + char *name;
  194. + {
  195. +   char *symdata, *p, *str_buff;
  196. +   long sym_count = 0, str_count = 0, i;
  197. +   struct misc_function *miscp;
  198. +   struct sym symb;
  199. + 
  200. +   /* grab the symbol table */
  201. + 
  202. +   symdata = alloca(segsize + 1);
  203. +   if (fread(symdata, segsize, 1, fp) != 1)
  204. +       perror_with_name(name);
  205. + 
  206. +   /* first pass, work out how many symbols there are and the size of the
  207. +    * strings
  208. +    */
  209. + 
  210. +   p = symdata;
  211. +   while (p < symdata + segsize)
  212. +   {
  213. +     int len;
  214. + 
  215. +     p += sizeof(struct sym);
  216. +     len = strlen(p) + 1;
  217. +     str_count += len;  p += len;  sym_count++;
  218. +   }
  219. + 
  220. +   /* Now build the misc function vector */
  221. + 
  222. +   str_buff = xmalloc(str_count+1);
  223. +   misc_function_vector =
  224. +     (struct misc_function *) xmalloc (sym_count * sizeof(struct misc_function));
  225. +   misc_function_count = sym_count;
  226. + 
  227. +   p = symdata;  miscp = misc_function_vector;
  228. +   while (p < symdata + segsize)
  229. +   {
  230. +     int len;
  231. + 
  232. +     symb = *((struct sym *)p);
  233. +     p += sizeof(struct sym);
  234. + 
  235. +     if (*p == '_')
  236. +       strcpy(str_buff, p+1);
  237. +     else
  238. +       strcpy(str_buff, p);
  239. + 
  240. +     /* the following will result in a garbage byte every time a symbol
  241. +      * starts with a _, I can'y be bothered to fix it.
  242. +      */
  243. + 
  244. +     miscp->name = str_buff;
  245. +     len = strlen(p) + 1;
  246. +     str_buff += len;  p += len;
  247. +     miscp->address = symb.s_value;
  248. +     switch(symb.s_type & S_TYPE)
  249. +     {
  250. +     case S_UNDEF:  miscp->type = mf_unknown;  break;
  251. +     case S_ABS:    miscp->type = mf_abs;  break;
  252. +     case S_TEXT:   miscp->type = mf_text;  break;
  253. +     case S_DATA:   miscp->type = mf_data;  break;
  254. +     case S_BSS:    miscp->type = mf_bss;  break;
  255. +     case S_COMM:   miscp->type = mf_data;  break;
  256. +     case S_REG:    miscp->type = mf_unknown;  break;
  257. +     case S_COMB:   miscp->type = mf_unknown;  break;
  258. +     case S_SEG:    miscp->type = mf_unknown;  break;
  259. +     case S_FN:     miscp->type = mf_unknown;  break;
  260. +     dewfault:      miscp->type = mf_unknown;  break;
  261. +     }
  262. +     miscp++;
  263. +   }
  264. + 
  265. +   qsort (misc_function_vector, misc_function_count,
  266. +     sizeof (struct misc_function), compare_misc_functions);
  267. + 
  268. + #ifdef X_DEBUG
  269. +   {
  270. +     struct misc_function *miscp;
  271. +     int i;
  272. + 
  273. +     printf("type      address  name\n\n");
  274. +     for (i = 0; i < misc_function_count; i++)
  275. +     {
  276. +       miscp = &misc_function_vector[i];
  277. +       switch (miscp->type)
  278. +       {
  279. +       case mf_unknown: printf("%-9s","unknown");  break;
  280. +       case mf_text:    printf("%-9s","text");  break;
  281. +       case mf_data:    printf("%-9s","data");  break;
  282. +       case mf_bss:     printf("%-9s","bss");  break;
  283. +       case mf_abs:     printf("%-9s","abs");  break;
  284. +       default:         printf("%-9s","UNKNOWN");  break;
  285. +       }
  286. +       printf("% 8x  ", miscp->address);
  287. +       printf("%s\n", miscp->name);
  288. +     }
  289. +   }
  290. + #endif /* X_DEBUG */
  291. +   return misc_function_count;
  292. + }
  293. + 
  294. + process_a_out(desc, name)
  295. + int desc;
  296. + char *name;
  297. + {
  298. +   struct xexec exec_aouthdr;
  299. +   struct xext *xext;
  300. +   struct xseg *cseg;
  301. +   FILE *fp;
  302. + 
  303. +   lseek(desc, 0L, 0);
  304. +   if ((fp = fdopen(dup(desc), "r")) == NULL)
  305. +         perror_with_name(name);
  306. + 
  307. +   if (fread((char *)&exec_aouthdr, sizeof(struct xexec), 1, fp) != 1)
  308. +     perror_with_name(name);
  309. +   
  310. +   xext = (struct xext *) alloca(exec_aouthdr.x_ext);
  311. +   if (fread((char *)xext, exec_aouthdr.x_ext, 1, fp) != 1)
  312. +     perror_with_name(name);
  313. +   
  314. +   read_seg_table(fp, xext->xe_segpos, xext->xe_segsize, name);
  315. + 
  316. +   if (cseg = find_segment(XS_TSYMS, 2))
  317. +   {
  318. +     fseek(fp, cseg->xs_filpos, 0);
  319. +     read_fileinfo_table(fp, cseg->xs_psize, name);
  320. +   }
  321. + 
  322. +   fclose(fp);
  323. + }
  324. + 
  325. + process_global_symbol_table(desc, name)
  326. + int desc;
  327. + char *name;
  328. + {
  329. +   struct xseg *cseg;
  330. +   FILE *fp;
  331. + 
  332. +   if ((fp = fdopen(dup(desc), "r")) == NULL)
  333. +         perror_with_name(name);
  334. + 
  335. +   if (cseg = find_segment(XS_TSYMS, 1))
  336. +   {
  337. +     fseek(fp, cseg->xs_filpos, 0);
  338. +     read_misc_functions(fp, cseg->xs_psize, name);
  339. +   }
  340. +   fclose(fp);
  341. + }
  342. + 
  343. + static struct fileinfo *current_fi;
  344. + static int first_get_fileinfo_call = 1;
  345. + 
  346. + init_fileinfo_processing()  /* start processing the list of files */
  347. + {
  348. +   first_get_fileinfo_call = 1;
  349. + }
  350. + 
  351. + long get_next_fileinfo(stroff, nsyms, address, symtaboff)
  352. + long *stroff, *nsyms, *address, *symtaboff;
  353. + {
  354. +   struct xseg *cseg;
  355. + 
  356. +   if (first_get_fileinfo_call)
  357. +   {
  358. +     current_fi = fi_table;
  359. +     first_get_fileinfo_call = 0;
  360. +   }
  361. +   else
  362. +     current_fi = current_fi->next;
  363. +   
  364. +   if (current_fi == 0)
  365. +     return 0;
  366. + 
  367. +   if (current_fi->mscdebuginfo)
  368. +   {
  369. +     *stroff = 0;
  370. +     *nsyms = 0;
  371. +     *address = current_fi->address;
  372. +   }
  373. +   else if (cseg = find_segment(XS_TSYMS, 5))
  374. +   {
  375. +     *symtaboff = cseg->xs_filpos + current_fi->ntaboff;
  376. +     *stroff = current_fi->strtaboff;
  377. +     *nsyms = current_fi->ntabsz / sizeof(struct gas_nlist);
  378. +     *address = current_fi->address;
  379. +     return 1;
  380. +   }
  381. +   else
  382. +   {
  383. +     *symtaboff = 0;
  384. +     *stroff = 0;
  385. +     *nsyms = 0;
  386. +     *address = 0;
  387. +   }
  388. + }
  389. + 
  390. + #ifdef TEST
  391. + 
  392. + main()
  393. + {
  394. +     char *stab;
  395. +     long str_offset, nsyms, address, ntaboff;
  396. +      int desc;
  397. +     struct xseg *cseg;
  398. + 
  399. +     process_a_out((desc = open("a.out", O_RDONLY, 0)), "a.out");
  400. + 
  401. +     printf("\n");
  402. + 
  403. +            if (cseg = find_segment(XS_TSYMS, 4))
  404. +            {
  405. +         lseek(desc, cseg->xs_filpos, 0);
  406. +         stab = alloca(cseg->xs_psize);
  407. +         read(desc, stab, cseg->xs_psize);
  408. +       }
  409. +       else
  410. +         stab = 0;
  411. + 
  412. +           init_fileinfo_processing();
  413. +       while (get_next_fileinfo(&str_offset,&nsyms,&address,&ntaboff))
  414. +       {
  415. +         lseek(desc, ntaboff, 0);
  416. +         printf("\n  type    desc     value  stroff  string (%#x)\n", address);
  417. +         while (nsyms--)
  418. +         {
  419. +           struct gas_nlist nl;
  420. + 
  421. +           read(desc, &nl, sizeof(nl));
  422. +           printf("% 6x  % 6x  % 8x  % 6x %s\n",
  423. +              (unsigned char)nl.n_type,
  424. +              (unsigned short)nl.n_desc,
  425. +              (unsigned int)nl.n_value,
  426. +              nl.n_un.n_strx ? stab + str_offset + nl.n_un.n_strx : "");
  427. +         }
  428. +         lseek(desc, 0L, 0);
  429. +       }
  430. + }
  431. + 
  432. + perror_with_name (string)
  433. +      char *string;
  434. + {
  435. +   extern int sys_nerr;
  436. +   extern char *sys_errlist[];
  437. +   extern int errno;
  438. +   char *err;
  439. +   char *combined;
  440. + 
  441. +   if (errno < sys_nerr)
  442. +     err = sys_errlist[errno];
  443. +   else
  444. +     err = "unknown error";
  445. + 
  446. +   combined = (char *) alloca (strlen (err) + strlen (string) + 3);
  447. +   strcpy (combined, string);
  448. +   strcat (combined, ": ");
  449. +   strcat (combined, err);
  450. + 
  451. +   error ("%s.", combined);
  452. + }
  453. + 
  454. + error (string, arg1, arg2, arg3)
  455. +      char *string;
  456. +      int arg1, arg2, arg3;
  457. + {
  458. +   fflush (stdout);
  459. +   fprintf (stderr, string, arg1, arg2, arg3);
  460. +   fprintf (stderr, "\n");
  461. +   exit(1);
  462. + }
  463. + 
  464. + char * xmalloc (size)
  465. +      long size;
  466. + {
  467. +   register char *val = (char *) malloc (size);
  468. +   if (!val)
  469. +     error ("virtual memory exhausted.");
  470. +   return val;
  471. + }
  472. + 
  473. + char *savestring (ptr, size)
  474. +      char *ptr;
  475. +      int size;
  476. + {
  477. +   register char *p = (char *) xmalloc (size + 1);
  478. +   memcpy(p, ptr, size);
  479. +   p[size] = 0;
  480. +   return p;
  481. + }
  482. + 
  483. + #endif /* TEST */
  484. *** dist-gdb.old/xenix386-dep.c    Thu Jan  1 00:00:00 1970
  485. --- xenix386-dep.c    Mon May  7 15:02:10 1990
  486. ***************
  487. *** 0 ****
  488. --- 1,1275 ----
  489. + /* Low level interface to ptrace, for GDB when running on the Intel 386.
  490. +    Copyright (C) 1988, 1989 Free Software Foundation, Inc.
  491. + 
  492. + This file is part of GDB.
  493. + 
  494. + GDB is free software; you can redistribute it and/or modify
  495. + it under the terms of the GNU General Public License as published by
  496. + the Free Software Foundation; either version 1, or (at your option)
  497. + any later version.
  498. + 
  499. + GDB is distributed in the hope that it will be useful,
  500. + but WITHOUT ANY WARRANTY; without even the implied warranty of
  501. + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  502. + GNU General Public License for more details.
  503. + 
  504. + You should have received a copy of the GNU General Public License
  505. + along with GDB; see the file COPYING.  If not, write to
  506. + the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  507. + 
  508. + #include <stdio.h>
  509. + #include "defs.h"
  510. + #include "param.h"
  511. + #include "frame.h"
  512. + #include "inferior.h"
  513. + 
  514. + #ifdef USG
  515. + #include <sys/types.h>
  516. + #endif
  517. + 
  518. + #include <stdio.h>
  519. + #include <sys/param.h>
  520. + #include <sys/dir.h>
  521. + #include <signal.h>
  522. + #ifdef M_XENIX
  523. + #include <sys/page.h>
  524. + #include <sys/seg.h>
  525. + #endif
  526. + #include <sys/user.h>
  527. + #include <sys/ioctl.h>
  528. + #include <fcntl.h>
  529. + 
  530. + #ifdef COFF_ENCAPSULATE
  531. + #include "a.out.encap.h"
  532. + #else
  533. + #ifndef M_XENIX            /* brain-dead xenix strikes again */
  534. + #include <a.out.h>
  535. + #endif
  536. + #endif
  537. + 
  538. + #ifndef N_SET_MAGIC
  539. + #ifdef COFF_FORMAT
  540. + #define N_SET_MAGIC(exec, val) ((exec).magic = (val))
  541. + #else
  542. + #define N_SET_MAGIC(aexec, val) ((aexec).xa_magic = (val))
  543. + #endif
  544. + #endif
  545. + 
  546. + #include <sys/file.h>
  547. + #include <sys/stat.h>
  548. + #include <sys/proc.h>
  549. + 
  550. + #include <sys/reg.h>
  551. + 
  552. + unsigned short text_segid;    /* segment number of text segment */
  553. + unsigned short data_segid;    /* segment number of data segment */
  554. + extern CORE_ADDR text_end; \
  555. + 
  556. + #ifdef X_DEBUG
  557. + Ptrace(l, a, b, c, d)
  558. + int l;
  559. + int a, b, c, d;
  560. + {
  561. +     printf("at line %d, req = %d, pid = %d, addr = %#x, data = %d\n",
  562. +            l, a, b, c, d);
  563. +         return ptrace (a, b, c, d);
  564. + }
  565. + 
  566. + #define ptrace(a,b,c,d) Ptrace(__LINE__, a, b, c, d)
  567. + #endif /* X_DEBUG */
  568. + 
  569. + typedef struct saddr PTRACE;
  570. + static PTRACE tmptrace;
  571. + extern int errno;
  572. + 
  573. + /* This function simply calls ptrace with the given arguments.  
  574. +    It exists so that all calls to ptrace are isolated in this 
  575. +    machine-dependent file. */
  576. + int
  577. + call_ptrace (request, pid, arg3, arg4)
  578. +      int request, pid, arg3, arg4;
  579. + {
  580. +   return ptrace (request, pid, arg3, arg4);
  581. + }
  582. + 
  583. + kill_inferior ()
  584. + {
  585. +   if (remote_debugging)
  586. +     return;
  587. +   if (inferior_pid == 0)
  588. +     return;
  589. +   ptrace (8, inferior_pid, 0, 0);
  590. +   wait (0);
  591. +   inferior_died ();
  592. + }
  593. + 
  594. + /* This is used when GDB is exiting.  It gives less chance of error.*/
  595. + 
  596. + kill_inferior_fast ()
  597. + {
  598. +   if (remote_debugging)
  599. +     return;
  600. +   if (inferior_pid == 0)
  601. +     return;
  602. +   ptrace (8, inferior_pid, 0, 0);
  603. +   wait (0);
  604. + }
  605. + 
  606. + /* Resume execution of the inferior process.
  607. +    If STEP is nonzero, single-step it.
  608. +    If SIGNAL is nonzero, give it that signal.  */
  609. + 
  610. + void
  611. + resume (step, signal)
  612. +      int step;
  613. +      int signal;
  614. + {
  615. +   PTRACE addr;
  616. +   addr.sa_seg = 0;
  617. +   addr.sa_off = 1;
  618. +   errno = 0;
  619. +   if (remote_debugging)
  620. +     remote_resume (step, signal);
  621. +   else
  622. +     {
  623. +       /* ptrace (step ? 9 : 7, inferior_pid, &addr, signal); */
  624. +       ptrace (step ? 9 : 7, inferior_pid, 1, signal);
  625. +       if (errno)
  626. +     perror_with_name ("ptrace");
  627. +     }
  628. + }
  629. + 
  630. + void
  631. + fetch_inferior_registers ()
  632. + {
  633. +   register int regno;
  634. +   register unsigned int regaddr;
  635. +   char buf[MAX_REGISTER_RAW_SIZE];
  636. +   register int i;
  637. + 
  638. +   struct user u;
  639. +   unsigned int offset = (char *) &u.u_ar0 - (char *) &u;
  640. +   offset = ptrace (3, inferior_pid, offset, 0) - KERNEL_U_ADDR;
  641. + 
  642. +   for (regno = 0; regno < NUM_REGS; regno++)
  643. +     {
  644. +       regaddr = register_addr (regno, offset);
  645. +       for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int))
  646. +      {
  647. +        *(int *) &buf[i] = ptrace (3, inferior_pid, regaddr, 0);
  648. +        regaddr += sizeof (int);
  649. +      }
  650. +       supply_register (regno, buf);
  651. +     }
  652. + }
  653. + 
  654. + /* Store our register values back into the inferior.
  655. +    If REGNO is -1, do this for all registers.
  656. +    Otherwise, REGNO specifies which register (so we can save time).  */
  657. + 
  658. + store_inferior_registers (regno)
  659. +      int regno;
  660. + {
  661. +   register unsigned int regaddr;
  662. +   char buf[80];
  663. + 
  664. +   struct user u;
  665. +   unsigned int offset = (char *) &u.u_ar0 - (char *) &u;
  666. +   offset = ptrace (3, inferior_pid, offset, 0) - KERNEL_U_ADDR;
  667. + 
  668. +   if (regno >= 0)
  669. +     {
  670. +       regaddr = register_addr (regno, offset);
  671. +       errno = 0;
  672. +       ptrace (6, inferior_pid, regaddr, read_register (regno));
  673. +       if (errno != 0)
  674. +     {
  675. +       sprintf (buf, "writing register number %d", regno);
  676. +       perror_with_name (buf);
  677. +     }
  678. +     }
  679. +   else for (regno = 0; regno < NUM_REGS; regno++)
  680. +     {
  681. +       regaddr = register_addr (regno, offset);
  682. +       errno = 0;
  683. +       ptrace (6, inferior_pid, regaddr, read_register (regno));
  684. +       if (errno != 0)
  685. +     {
  686. +       sprintf (buf, "writing register number %d", regno);
  687. +       perror_with_name (buf);
  688. +     }
  689. +     }
  690. + }
  691. + 
  692. + /* Copy LEN bytes from inferior's memory starting at MEMADDR
  693. +    to debugger memory starting at MYADDR. 
  694. +    On failure (cannot read from inferior, usually because address is out
  695. +    of bounds) returns the value of errno. */
  696. + 
  697. + int
  698. + read_inferior_memory (memaddr, myaddr, len)
  699. +      CORE_ADDR memaddr;
  700. +      char *myaddr;
  701. +      int len;
  702. + {
  703. +   register int i;
  704. +   /* Round starting address down to longword boundary.  */
  705. +   register CORE_ADDR addr = memaddr & - sizeof (int);
  706. +   /* Round ending address up; get number of longwords that makes.  */
  707. +   register int count
  708. +     = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
  709. +   /* Allocate buffer of that many longwords.  */
  710. +   register int *buffer = (int *) alloca (count * sizeof (int));
  711. +   extern int errno;
  712. + 
  713. +   /* Read all the longwords */
  714. +   for (i = 0; i < count; i++, addr += sizeof (int))
  715. +     {
  716. +       errno = 0;
  717. +       if (remote_debugging)
  718. +     buffer[i] = remote_fetch_word (addr);
  719. +       else
  720. +     buffer[i] = ptrace (addr <= text_end ? 1 : 2, inferior_pid,
  721. +         addr, 0);
  722. +       if (errno)
  723. +     return errno;
  724. +     }
  725. + 
  726. +   /* Copy appropriate bytes out of the buffer.  */
  727. +   bcopy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
  728. +   return 0;
  729. + }
  730. + 
  731. + /* Copy LEN bytes of data from debugger memory at MYADDR
  732. +    to inferior's memory at MEMADDR.
  733. +    On failure (cannot write the inferior)
  734. +    returns the value of errno.  */
  735. + 
  736. + int
  737. + write_inferior_memory (memaddr, myaddr, len)
  738. +      CORE_ADDR memaddr;
  739. +      char *myaddr;
  740. +      int len;
  741. + {
  742. +   register int i;
  743. +   /* Round starting address down to longword boundary.  */
  744. +   register CORE_ADDR addr = memaddr & - sizeof (int);
  745. +   /* Round ending address up; get number of longwords that makes.  */
  746. +   register int count
  747. +     = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
  748. +   /* Allocate buffer of that many longwords.  */
  749. +   register int *buffer = (int *) alloca (count * sizeof (int));
  750. +   extern int errno;
  751. + 
  752. +   /* Fill start and end extra bytes of buffer with existing memory data.  */
  753. + 
  754. +   if (remote_debugging)
  755. +     buffer[0] = remote_fetch_word (addr);
  756. +   else
  757. +     buffer[0] = ptrace (addr <= text_end ? 1 : 2, inferior_pid, addr, 0);
  758. + 
  759. +   if (count > 1)
  760. +     {
  761. +       if (remote_debugging)
  762. +     buffer[count - 1]
  763. +       = remote_fetch_word (addr + (count - 1) * sizeof (int));
  764. +       else
  765. +     buffer[count - 1]
  766. +       = ptrace (addr <= text_end ? 1 : 2, inferior_pid,
  767. +                    (addr + (count - 1) * sizeof(int)) , 0);
  768. +     }
  769. + 
  770. +   /* Copy data to be written over corresponding part of buffer */
  771. + 
  772. +   bcopy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
  773. + 
  774. +   /* Write the entire buffer.  */
  775. + 
  776. +   for (i = 0; i < count; i++, addr += sizeof (int))
  777. +     {
  778. +       errno = 0;
  779. +       if (remote_debugging)
  780. +     remote_store_word (addr, buffer[i]);
  781. +       else
  782. +     ptrace (addr <= text_end ? 4 : 5, inferior_pid, addr, buffer[i]);
  783. +       if (errno)
  784. +     return errno;
  785. +     }
  786. + 
  787. +   return 0;
  788. + }
  789. + 
  790. + /* Work with core dump and executable files, for GDB. 
  791. +    This code would be in core.c if it weren't machine-dependent. */
  792. + 
  793. + #ifndef N_TXTADDR
  794. + #define N_TXTADDR(hdr) 0
  795. + #endif /* no N_TXTADDR */
  796. + 
  797. + #ifndef N_DATADDR
  798. + #define N_DATADDR(hdr) hdr.xa_text
  799. + #endif /* no N_DATADDR */
  800. + 
  801. + /* Make COFF and non-COFF names for things a little more compatible
  802. +    to reduce conditionals later.  */
  803. + 
  804. + #define AOUTHDR struct xexec
  805. + 
  806. + extern char *sys_siglist[];
  807. + 
  808. + 
  809. + /* Hook for `exec_file_command' command to call.  */
  810. + 
  811. + extern void (*exec_file_display_hook) ();
  812. +    
  813. + /* File names of core file and executable file.  */
  814. + 
  815. + extern char *corefile;
  816. + extern char *execfile;
  817. + 
  818. + /* Descriptors on which core file and executable file are open.
  819. +    Note that the execchan is closed when an inferior is created
  820. +    and reopened if the inferior dies or is killed.  */
  821. + 
  822. + extern int corechan;
  823. + extern int execchan;
  824. + 
  825. + /* Last modification time of executable file.
  826. +    Also used in source.c to compare against mtime of a source file.  */
  827. + 
  828. + extern int exec_mtime;
  829. + 
  830. + /* Virtual addresses of bounds of the two areas of memory in the core file.  */
  831. + 
  832. + extern CORE_ADDR data_start;
  833. + extern CORE_ADDR data_end;
  834. + extern CORE_ADDR stack_start;
  835. + extern CORE_ADDR stack_end;
  836. + 
  837. + /* Virtual addresses of bounds of two areas of memory in the exec file.
  838. +    Note that the data area in the exec file is used only when there is no core file.  */
  839. + 
  840. + extern CORE_ADDR text_start;
  841. + extern CORE_ADDR text_end;
  842. + 
  843. + extern CORE_ADDR exec_data_start;
  844. + extern CORE_ADDR exec_data_end;
  845. + 
  846. + /* Address in executable file of start of text area data.  */
  847. + 
  848. + extern int text_offset;
  849. + 
  850. + /* Address in executable file of start of data area data.  */
  851. + 
  852. + extern int exec_data_offset;
  853. + 
  854. + /* Address in core file of start of data area data.  */
  855. + 
  856. + extern int data_offset;
  857. + 
  858. + /* Address in core file of start of stack area data.  */
  859. + 
  860. + extern int stack_offset;
  861. + 
  862. + #ifdef COFF_FORMAT
  863. + /* various coff data structures */
  864. + 
  865. + extern FILHDR file_hdr;
  866. + extern SCNHDR text_hdr;
  867. + extern SCNHDR data_hdr;
  868. + 
  869. + #endif /* not COFF_FORMAT */
  870. + 
  871. + /* a.out header saved in core file.  */
  872. +   
  873. + extern AOUTHDR core_aouthdr;
  874. + 
  875. + /* a.out header of exec file.  */
  876. + 
  877. + extern AOUTHDR exec_aouthdr;
  878. + 
  879. + extern void validate_files ();
  880. + 
  881. + core_file_command (filename, from_tty)
  882. +      char *filename;
  883. +      int from_tty;
  884. + {
  885. +   int val;
  886. + 
  887. +   /* Discard all vestiges of any previous core file
  888. +      and mark data and stack spaces as empty.  */
  889. + 
  890. +   if (corefile)
  891. +     free (corefile);
  892. +   corefile = 0;
  893. + 
  894. +   if (corechan >= 0)
  895. +     close (corechan);
  896. +   corechan = -1;
  897. + 
  898. +   data_start = 0;
  899. +   data_end = 0;
  900. +   stack_start = 0;
  901. +   stack_end = 0;
  902. + 
  903. +   /* Now, if a new core file was specified, open it and digest it.  */
  904. + 
  905. +   if (filename)
  906. +     {
  907. +       filename = tilde_expand (filename);
  908. +       make_cleanup (free, filename);
  909. +       
  910. +       if (have_inferior_p ())
  911. +     error ("To look at a core file, you must kill the inferior with \"kill\".");
  912. +       corechan = open (filename, O_RDONLY, 0);
  913. +       if (corechan < 0)
  914. +     perror_with_name (filename);
  915. +       /* xenix style core dump */
  916. +       {
  917. +     struct user u;
  918. +     long user_area_size;
  919. +     int reg_offset;
  920. + 
  921. + 
  922. +     val = myread (corechan, &u, sizeof u);
  923. +     if (val < 0)
  924. +       perror_with_name (filename);
  925. + 
  926. +     user_area_size = ((sizeof u + (u.u_ldtlimit-1)*sizeof(struct descriptor)
  927. +              + NBPC - 1) / NBPC) * NBPC;
  928. + 
  929. +     data_start = (CORE_ADDR)u.u_sdata;
  930. +     data_end = (CORE_ADDR)u.u_edatau;
  931. +     stack_start = (CORE_ADDR)u.u_stktop;
  932. +     stack_end = (CORE_ADDR)u.u_stkbotu;
  933. + 
  934. +     data_offset = lseek(corechan, 0L, 2) - u.u_dsize;
  935. +     stack_offset = user_area_size;
  936. +     reg_offset = (int) u.u_ar0 - KERNEL_U_ADDR;
  937. + #ifdef X_DEBUG
  938. +     printf("data_offset = %#x\n", data_offset);
  939. +     printf("stack_offset  = %#x\n", stack_offset );
  940. +     printf("user_area_size = %#x\n", user_area_size);
  941. +     printf("test data_offset = %#x\n", user_area_size + u.u_ssize);
  942. + #endif /* X_DEBUG */
  943. + 
  944. +     /* I don't know where to find this info.
  945. +        So, for now, mark it as not available.  */
  946. + /*    N_SET_MAGIC (core_aouthdr, 0);  */
  947. +     bzero ((char *) &core_aouthdr, sizeof core_aouthdr);
  948. + 
  949. +     /* Read the register values out of the core file and store
  950. +        them where `read_register' will find them.  */
  951. + 
  952. +     {
  953. +       register int regno;
  954. + 
  955. +       for (regno = 0; regno < NUM_REGS; regno++)
  956. +         {
  957. +           char buf[MAX_REGISTER_RAW_SIZE];
  958. + 
  959. +           val = lseek (corechan, register_addr (regno, reg_offset), 0);
  960. +           if (val < 0)
  961. +         perror_with_name (filename);
  962. + 
  963. +            val = myread (corechan, buf, sizeof buf);
  964. +           if (val < 0)
  965. +         perror_with_name (filename);
  966. +           supply_register (regno, buf);
  967. +         }
  968. +     }
  969. +       }
  970. +       if (filename[0] == '/')
  971. +     corefile = savestring (filename, strlen (filename));
  972. +       else
  973. +     {
  974. +       corefile = concat (current_directory, "/", filename);
  975. +     }
  976. + 
  977. +       set_current_frame ( create_new_frame (read_register (FP_REGNUM),
  978. +                         read_pc ()));
  979. +       select_frame (get_current_frame (), 0);
  980. +       validate_files ();
  981. +     }
  982. +   else if (from_tty)
  983. +     printf ("No core file now.\n");
  984. + }
  985. + 
  986. + exec_file_command (filename, from_tty)
  987. +      char *filename;
  988. +      int from_tty;
  989. + {
  990. +   int val;
  991. + 
  992. +   /* Eliminate all traces of old exec file.
  993. +      Mark text segment as empty.  */
  994. + 
  995. +   if (execfile)
  996. +     free (execfile);
  997. +   execfile = 0;
  998. +   data_start = 0;
  999. +   data_end -= exec_data_start;
  1000. +   text_start = 0;
  1001. +   text_end = 0;
  1002. +   exec_data_start = 0;
  1003. +   exec_data_end = 0;
  1004. +   if (execchan >= 0)
  1005. +     close (execchan);
  1006. +   execchan = -1;
  1007. + 
  1008. +   /* Now open and digest the file the user requested, if any.  */
  1009. + 
  1010. +   if (filename)
  1011. +     {
  1012. +       filename = tilde_expand (filename);
  1013. +       make_cleanup (free, filename);
  1014. +       
  1015. +       execchan = openp (getenv ("PATH"), 1, filename, O_RDONLY, 0,
  1016. +             &execfile);
  1017. +       if (execchan < 0)
  1018. +     perror_with_name (filename);
  1019. + 
  1020. +       {
  1021. +     char *extended_header;
  1022. +     struct xext *xext;
  1023. +     struct stat st_exec;
  1024. +     struct xseg xseg;
  1025. +     extern char *malloc();
  1026. +     val = myread (execchan, &exec_aouthdr, sizeof (AOUTHDR));
  1027. + 
  1028. +     if (val < 0)
  1029. +       perror_with_name (filename);
  1030. +         if (exec_aouthdr.x_magic != X_MAGIC)
  1031. +       error ("\"%s\": not in executable format.", execfile);
  1032. +     if ( (exec_aouthdr.x_cpu & XC_CPU) != XC_386 )
  1033. +       error ("\"%s\": not a 386 executable.", execfile);
  1034. +     if ( (exec_aouthdr.x_renv & XE_SEG) == 0)
  1035. +       error ("\"%s\": not a segmented executable.", execfile);
  1036. +     if ( (exec_aouthdr.x_renv & XE_EXEC) == 0)
  1037. +       error ("\"%s\": not executable.", execfile);
  1038. +     extended_header = malloc(exec_aouthdr.x_ext);
  1039. +     val = myread (execchan, extended_header, exec_aouthdr.x_ext);
  1040. +     if (val < 0)
  1041. +       perror_with_name (filename);
  1042. +     xext = (struct xext *)extended_header;
  1043. +     lseek(execchan, xext->xe_segpos, 0);
  1044. +     if (myread (execchan, (char *)&xseg, sizeof(xseg)) < 0)
  1045. +       perror_with_name (filename);
  1046. +     if ( xseg.xs_type != XS_TTEXT )
  1047. +       error ("\"%s\": Text segment isn't first (huh?).", execfile);
  1048. +     text_segid = xseg.xs_seg;
  1049. +     text_start = xseg.xs_rbase;
  1050. +     text_end = text_start + xseg.xs_vsize;
  1051. +     text_offset = xseg.xs_filpos;
  1052. + 
  1053. +     if (myread (execchan, (char *)&xseg, sizeof(xseg)) < 0)
  1054. +       perror_with_name (filename);
  1055. +     if ( xseg.xs_type != XS_TDATA )
  1056. +       error ("\"%s\": Data segment isn't second (huh?).", execfile);
  1057. +     data_segid = xseg.xs_seg;
  1058. +     exec_data_start = xseg.xs_rbase;
  1059. +     exec_data_end = exec_data_start + xseg.xs_psize;
  1060. +     exec_data_offset = xseg.xs_filpos;
  1061. +     data_start = exec_data_start;
  1062. +     data_end += exec_data_start;
  1063. +     
  1064. +     fstat (execchan, &st_exec);
  1065. +     exec_mtime = st_exec.st_mtime;
  1066. +     free(extended_header);
  1067. +       }
  1068. + 
  1069. +       validate_files ();
  1070. +     }
  1071. +   else if (from_tty)
  1072. +     printf ("No exec file now.\n");
  1073. + 
  1074. +   /* Tell display code (if any) about the changed file name.  */
  1075. +   if (exec_file_display_hook)
  1076. +     (*exec_file_display_hook) (filename);
  1077. + }
  1078. + 
  1079. + /* helper functions for m-i386.h */
  1080. + 
  1081. + /* stdio style buffering to minimize calls to ptrace */
  1082. + static CORE_ADDR codestream_next_addr;
  1083. + static CORE_ADDR codestream_addr;
  1084. + static unsigned char codestream_buf[sizeof (int)];
  1085. + static int codestream_off;
  1086. + static int codestream_cnt;
  1087. + 
  1088. + #define codestream_tell() (codestream_addr + codestream_off)
  1089. + #define codestream_peek() (codestream_cnt == 0 ? \
  1090. +                codestream_fill(1): codestream_buf[codestream_off])
  1091. + #define codestream_get() (codestream_cnt-- == 0 ? \
  1092. +              codestream_fill(0) : codestream_buf[codestream_off++])
  1093. + 
  1094. + static unsigned char 
  1095. + codestream_fill (peek_flag)
  1096. + {
  1097. +   codestream_addr = codestream_next_addr;
  1098. +   codestream_next_addr += sizeof (int);
  1099. +   codestream_off = 0;
  1100. +   codestream_cnt = sizeof (int);
  1101. +   read_memory (codestream_addr,
  1102. +            (unsigned char *)codestream_buf,
  1103. +            sizeof (int));
  1104. +   
  1105. +   if (peek_flag)
  1106. +     return (codestream_peek());
  1107. +   else
  1108. +     return (codestream_get());
  1109. + }
  1110. + 
  1111. + static void
  1112. + codestream_seek (place)
  1113. + {
  1114. +   codestream_next_addr = place & -sizeof (int);
  1115. +   codestream_cnt = 0;
  1116. +   codestream_fill (1);
  1117. +   while (codestream_tell() != place)
  1118. +     codestream_get ();
  1119. + }
  1120. + 
  1121. + static void
  1122. + codestream_read (buf, count)
  1123. +      unsigned char *buf;
  1124. + {
  1125. +   unsigned char *p;
  1126. +   int i;
  1127. +   p = buf;
  1128. +   for (i = 0; i < count; i++)
  1129. +     *p++ = codestream_get ();
  1130. + }
  1131. + 
  1132. + /* next instruction is a jump, move to target */
  1133. + static
  1134. + i386_follow_jump ()
  1135. + {
  1136. +   int long_delta;
  1137. +   short short_delta;
  1138. +   char byte_delta;
  1139. +   int data16;
  1140. +   int pos;
  1141. +   
  1142. +   pos = codestream_tell ();
  1143. +   
  1144. +   data16 = 0;
  1145. +   if (codestream_peek () == 0x66)
  1146. +     {
  1147. +       codestream_get ();
  1148. +       data16 = 1;
  1149. +     }
  1150. +   
  1151. +   switch (codestream_get ())
  1152. +     {
  1153. +     case 0xe9:
  1154. +       /* relative jump: if data16 == 0, disp32, else disp16 */
  1155. +       if (data16)
  1156. +     {
  1157. +       codestream_read ((unsigned char *)&short_delta, 2);
  1158. +       pos += short_delta + 3; /* include size of jmp inst */
  1159. +     }
  1160. +       else
  1161. +     {
  1162. +       codestream_read ((unsigned char *)&long_delta, 4);
  1163. +       pos += long_delta + 5;
  1164. +     }
  1165. +       break;
  1166. +     case 0xeb:
  1167. +       /* relative jump, disp8 (ignore data16) */
  1168. +       codestream_read ((unsigned char *)&byte_delta, 1);
  1169. +       pos += byte_delta + 2;
  1170. +       break;
  1171. +     }
  1172. +   codestream_seek (pos + data16);
  1173. + }
  1174. + 
  1175. + /*
  1176. +  * find & return amound a local space allocated, and advance codestream to
  1177. +  * first register push (if any)
  1178. +  *
  1179. +  * if entry sequence doesn't make sense, return -1, and leave 
  1180. +  * codestream pointer random
  1181. +  */
  1182. + static long
  1183. + i386_get_frame_setup (pc)
  1184. + {
  1185. +   unsigned char op;
  1186. +   
  1187. +   codestream_seek (pc);
  1188. +   
  1189. +   i386_follow_jump ();
  1190. +   
  1191. +   op = codestream_get ();
  1192. +   
  1193. +   if (op == 0x58)        /* popl %eax */
  1194. +     {
  1195. +       /*
  1196. +        * this function must start with
  1197. +        * 
  1198. +        *    popl %eax          0x58
  1199. +        *    xchgl %eax, (%esp)  0x87 0x04 0x24
  1200. +        * or xchgl %eax, 0(%esp) 0x87 0x44 0x24 0x00
  1201. +        *
  1202. +        * (the system 5 compiler puts out the second xchg
  1203. +        * inst, and the assembler doesn't try to optimize it,
  1204. +        * so the 'sib' form gets generated)
  1205. +        * 
  1206. +        * this sequence is used to get the address of the return
  1207. +        * buffer for a function that returns a structure
  1208. +        */
  1209. +       int pos;
  1210. +       unsigned char buf[4];
  1211. +       static unsigned char proto1[3] = { 0x87,0x04,0x24 };
  1212. +       static unsigned char proto2[4] = { 0x87,0x44,0x24,0x00 };
  1213. +       pos = codestream_tell ();
  1214. +       codestream_read (buf, 4);
  1215. +       if (bcmp (buf, proto1, 3) == 0)
  1216. +     pos += 3;
  1217. +       else if (bcmp (buf, proto2, 4) == 0)
  1218. +     pos += 4;
  1219. +       
  1220. +       codestream_seek (pos);
  1221. +       op = codestream_get (); /* update next opcode */
  1222. +     }
  1223. +   
  1224. +   if (op == 0x55)        /* pushl %esp */
  1225. +     {            
  1226. +       /* check for movl %esp, %ebp - can be written two ways */
  1227. +       switch (codestream_get ())
  1228. +     {
  1229. +     case 0x8b:
  1230. +       if (codestream_get () != 0xec)
  1231. +         return (-1);
  1232. +       break;
  1233. +     case 0x89:
  1234. +       if (codestream_get () != 0xe5)
  1235. +         return (-1);
  1236. +       break;
  1237. +     default:
  1238. +       return (-1);
  1239. +     }
  1240. +       /* check for stack adjustment 
  1241. +        *
  1242. +        *  subl $XXX, %esp
  1243. +        *
  1244. +        * note: you can't subtract a 16 bit immediate
  1245. +        * from a 32 bit reg, so we don't have to worry
  1246. +        * about a data16 prefix 
  1247. +        */
  1248. +       op = codestream_peek ();
  1249. +       if (op == 0x83)
  1250. +     {
  1251. +       /* subl with 8 bit immed */
  1252. +       codestream_get ();
  1253. +       if (codestream_get () != 0xec)
  1254. +         return (-1);
  1255. +       /* subl with signed byte immediate 
  1256. +        * (though it wouldn't make sense to be negative)
  1257. +        */
  1258. +       return (codestream_get());
  1259. +     }
  1260. +       else if (op == 0x81)
  1261. +     {
  1262. +       /* subl with 32 bit immed */
  1263. +       int locals;
  1264. +       codestream_get();
  1265. +       if (codestream_get () != 0xec)
  1266. +         return (-1);
  1267. +       /* subl with 32 bit immediate */
  1268. +       codestream_read ((unsigned char *)&locals, 4);
  1269. +       return (locals);
  1270. +     }
  1271. +       else
  1272. +     {
  1273. +       return (0);
  1274. +     }
  1275. +     }
  1276. +   else if (op == 0xc8)
  1277. +     {
  1278. +       /* enter instruction: arg is 16 bit unsigned immed */
  1279. +       unsigned short slocals;
  1280. +       codestream_read ((unsigned char *)&slocals, 2);
  1281. +       codestream_get (); /* flush final byte of enter instruction */
  1282. +       return (slocals);
  1283. +     }
  1284. +   return (-1);
  1285. + }
  1286. + 
  1287. + /* Return number of args passed to a frame.
  1288. +    Can return -1, meaning no way to tell.  */
  1289. + 
  1290. + /* on the 386, the instruction following the call could be:
  1291. +  *  popl %ecx        -  one arg
  1292. +  *  addl $imm, %esp  -  imm/4 args; imm may be 8 or 32 bits
  1293. +  *  anything else    -  zero args
  1294. +  */
  1295. + 
  1296. + int
  1297. + i386_frame_num_args (fi)
  1298. +      struct frame_info fi;
  1299. + {
  1300. +   int retpc;                        
  1301. +   unsigned char op;                    
  1302. +   struct frame_info *pfi;
  1303. + 
  1304. +   pfi = get_prev_frame_info ((fi));            
  1305. +   if (pfi == 0)
  1306. +     {
  1307. +       /* Note:  this can happen if we are looking at the frame for
  1308. +      main, because FRAME_CHAIN_VALID won't let us go into
  1309. +      start.  If we have debugging symbols, that's not really
  1310. +      a big deal; it just means it will only show as many arguments
  1311. +      to main as are declared.  */
  1312. +       return -1;
  1313. +     }
  1314. +   else
  1315. +     {
  1316. +       retpc = pfi->pc;                    
  1317. +       op = read_memory_integer (retpc, 1);            
  1318. +       if (op == 0x59)                    
  1319. +     /* pop %ecx */                   
  1320. +     return 1;                
  1321. +       else if (op == 0x83)
  1322. +     {
  1323. +       op = read_memory_integer (retpc+1, 1);    
  1324. +       if (op == 0xc4)                
  1325. +         /* addl $<signed imm 8 bits>, %esp */    
  1326. +         return (read_memory_integer (retpc+2,1)&0xff)/4;
  1327. +       else
  1328. +         return 0;
  1329. +     }
  1330. +       else if (op == 0x81)
  1331. +     { /* add with 32 bit immediate */
  1332. +       op = read_memory_integer (retpc+1, 1);    
  1333. +       if (op == 0xc4)                
  1334. +         /* addl $<imm 32>, %esp */        
  1335. +         return read_memory_integer (retpc+2, 4) / 4;
  1336. +       else
  1337. +         return 0;
  1338. +     }
  1339. +       else
  1340. +     {
  1341. +       return 0;
  1342. +     }
  1343. +     }
  1344. + }
  1345. + 
  1346. + /*
  1347. +  * parse the first few instructions of the function to see
  1348. +  * what registers were stored.
  1349. +  *
  1350. +  * We handle these cases:
  1351. +  *
  1352. +  * The startup sequence can be at the start of the function,
  1353. +  * or the function can start with a branch to startup code at the end.
  1354. +  *
  1355. +  * %ebp can be set up with either the 'enter' instruction, or 
  1356. +  * 'pushl %ebp, movl %esp, %ebp' (enter is too slow to be useful,
  1357. +  * but was once used in the sys5 compiler)
  1358. +  *
  1359. +  * Local space is allocated just below the saved %ebp by either the
  1360. +  * 'enter' instruction, or by 'subl $<size>, %esp'.  'enter' has
  1361. +  * a 16 bit unsigned argument for space to allocate, and the
  1362. +  * 'addl' instruction could have either a signed byte, or
  1363. +  * 32 bit immediate.
  1364. +  *
  1365. +  * Next, the registers used by this function are pushed.  In
  1366. +  * the sys5 compiler they will always be in the order: %edi, %esi, %ebx
  1367. +  * (and sometimes a harmless bug causes it to also save but not restore %eax);
  1368. +  * however, the code below is willing to see the pushes in any order,
  1369. +  * and will handle up to 8 of them.
  1370. +  *
  1371. +  * If the setup sequence is at the end of the function, then the
  1372. +  * next instruction will be a branch back to the start.
  1373. +  */
  1374. + 
  1375. + i386_frame_find_saved_regs (fip, fsrp)
  1376. +      struct frame_info *fip;
  1377. +      struct frame_saved_regs *fsrp;
  1378. + {
  1379. +   unsigned long locals;
  1380. +   unsigned char *p;
  1381. +   unsigned char op;
  1382. +   CORE_ADDR dummy_bottom;
  1383. +   CORE_ADDR adr;
  1384. +   int i;
  1385. +   
  1386. +   bzero (fsrp, sizeof *fsrp);
  1387. +   
  1388. +   /* if frame is the end of a dummy, compute where the
  1389. +    * beginning would be
  1390. +    */
  1391. +   dummy_bottom = fip->frame - 4 - NUM_REGS*4 - CALL_DUMMY_LENGTH;
  1392. +   
  1393. +   /* check if the PC is in the stack, in a dummy frame */
  1394. +   if (dummy_bottom <= fip->pc && fip->pc <= fip->frame) 
  1395. +     {
  1396. +       /* all regs were saved by push_call_dummy () */
  1397. +       adr = fip->frame - 4;
  1398. +       for (i = 0; i < NUM_REGS; i++) 
  1399. +     {
  1400. +       fsrp->regs[i] = adr;
  1401. +       adr -= 4;
  1402. +     }
  1403. +       return;
  1404. +     }
  1405. +   
  1406. +   locals = i386_get_frame_setup (get_pc_function_start (fip->pc));
  1407. +   
  1408. +   if (locals >= 0) 
  1409. +     {
  1410. +       adr = fip->frame - 4 - locals;
  1411. +       for (i = 0; i < 8; i++) 
  1412. +     {
  1413. +       op = codestream_get ();
  1414. +       if (op < 0x50 || op > 0x57)
  1415. +         break;
  1416. +       fsrp->regs[op - 0x50] = adr;
  1417. +       adr -= 4;
  1418. +     }
  1419. +     }
  1420. +   
  1421. +   fsrp->regs[PC_REGNUM] = fip->frame + 4;
  1422. +   fsrp->regs[FP_REGNUM] = fip->frame;
  1423. + }
  1424. + 
  1425. + /* return pc of first real instruction */
  1426. + i386_skip_prologue (pc)
  1427. + {
  1428. +   unsigned char op;
  1429. +   int i;
  1430. +   
  1431. +   if (i386_get_frame_setup (pc) < 0)
  1432. +     return (pc);
  1433. +   
  1434. +   /* found valid frame setup - codestream now points to 
  1435. +    * start of push instructions for saving registers
  1436. +    */
  1437. +   
  1438. +   /* skip over register saves */
  1439. +   for (i = 0; i < 8; i++)
  1440. +     {
  1441. +       op = codestream_peek ();
  1442. +       /* break if not pushl inst */
  1443. +       if (op < 0x50 || op > 0x57) 
  1444. +     break;
  1445. +       codestream_get ();
  1446. +     }
  1447. +   
  1448. +   i386_follow_jump ();
  1449. +   
  1450. +   return (codestream_tell ());
  1451. + }
  1452. + 
  1453. + i386_push_dummy_frame ()
  1454. + {
  1455. +   CORE_ADDR sp = read_register (SP_REGNUM);
  1456. +   int regnum;
  1457. +   
  1458. +   sp = push_word (sp, read_register (PC_REGNUM));
  1459. +   sp = push_word (sp, read_register (FP_REGNUM));
  1460. +   write_register (FP_REGNUM, sp);
  1461. +   for (regnum = 0; regnum < NUM_REGS; regnum++)
  1462. +     sp = push_word (sp, read_register (regnum));
  1463. +   write_register (SP_REGNUM, sp);
  1464. + }
  1465. + 
  1466. + i386_pop_frame ()
  1467. + {
  1468. +   FRAME frame = get_current_frame ();
  1469. +   CORE_ADDR fp;
  1470. +   int regnum;
  1471. +   struct frame_saved_regs fsr;
  1472. +   struct frame_info *fi;
  1473. +   
  1474. +   fi = get_frame_info (frame);
  1475. +   fp = fi->frame;
  1476. +   get_frame_saved_regs (fi, &fsr);
  1477. +   for (regnum = 0; regnum < NUM_REGS; regnum++) 
  1478. +     {
  1479. +       CORE_ADDR adr;
  1480. +       adr = fsr.regs[regnum];
  1481. +       if (adr)
  1482. +     write_register (regnum, read_memory_integer (adr, 4));
  1483. +     }
  1484. +   write_register (FP_REGNUM, read_memory_integer (fp, 4));
  1485. +   write_register (PC_REGNUM, read_memory_integer (fp + 4, 4));
  1486. +   write_register (SP_REGNUM, fp + 8);
  1487. +   flush_cached_frames ();
  1488. +   set_current_frame ( create_new_frame (read_register (FP_REGNUM),
  1489. +                     read_pc ()));
  1490. + }
  1491. + 
  1492. + /* this table must line up with REGISTER_NAMES in m-i386.h */
  1493. + /* symbols like 'EAX' come from <sys/reg.h> */
  1494. + static int regmap[] = 
  1495. + {
  1496. +   REAX, RECX, REDX, REBX,
  1497. +   RESP, REBP, RESI, REDI,
  1498. +   REIP, REFL, RCS, RSS,
  1499. +   RDS, RES, RFS, RGS,
  1500. + };
  1501. + 
  1502. + /* blockend is the value of u.u_ar0, and points to the
  1503. +  * place where GS is stored
  1504. +  */
  1505. + i386_register_u_addr (blockend, regnum)
  1506. + {
  1507. + #if 0
  1508. +   /* this will be needed if fp registers are reinstated */
  1509. +   /* for now, you can look at them with 'info float'
  1510. +    * sys5 wont let you change them with ptrace anyway
  1511. +    */
  1512. +   if (regnum >= FP0_REGNUM && regnum <= FP7_REGNUM) 
  1513. +     {
  1514. +       int ubase, fpstate;
  1515. +       struct user u;
  1516. +       ubase = blockend + 4 * (SS + 1) - KSTKSZ;
  1517. +       fpstate = ubase + ((char *)&u.u_fpstate - (char *)&u);
  1518. +       return (fpstate + 0x1c + 10 * (regnum - FP0_REGNUM));
  1519. +     } 
  1520. +   else
  1521. + #endif
  1522. +     return (blockend + 4 * regmap[regnum]);
  1523. +   
  1524. + }
  1525. + 
  1526. + i387_to_double (from, to)
  1527. +      char *from;
  1528. +      char *to;
  1529. + {
  1530. +   long *lp;
  1531. +   /* push extended mode on 387 stack, then pop in double mode
  1532. +    *
  1533. +    * first, set exception masks so no error is generated -
  1534. +    * number will be rounded to inf or 0, if necessary 
  1535. +    */
  1536. +   asm ("pushl %eax");         /* grab a stack slot */
  1537. +   asm ("fstcw (%esp)");        /* get 387 control word */
  1538. +   asm ("movl (%esp),%eax");    /* save old value */
  1539. +   asm ("orl $0x3f,%eax");        /* mask all exceptions */
  1540. +   asm ("pushl %eax");
  1541. +   asm ("fldcw (%esp)");        /* load new value into 387 */
  1542. +   
  1543. +   asm ("movl 8(%ebp),%eax");
  1544. +   asm ("fldt (%eax)");        /* push extended number on 387 stack */
  1545. +   asm ("fwait");
  1546. +   asm ("movl 12(%ebp),%eax");
  1547. +   asm ("fstpl (%eax)");        /* pop double */
  1548. +   asm ("fwait");
  1549. +   
  1550. +   asm ("popl %eax");        /* flush modified control word */
  1551. +   asm ("fnclex");            /* clear exceptions */
  1552. +   asm ("fldcw (%esp)");        /* restore original control word */
  1553. +   asm ("popl %eax");        /* flush saved copy */
  1554. + }
  1555. + 
  1556. + double_to_i387 (from, to)
  1557. +      char *from;
  1558. +      char *to;
  1559. + {
  1560. +   /* push double mode on 387 stack, then pop in extended mode
  1561. +    * no errors are possible because every 64-bit pattern
  1562. +    * can be converted to an extended
  1563. +    */
  1564. +   asm ("movl 8(%ebp),%eax");
  1565. +   asm ("fldl (%eax)");
  1566. +   asm ("fwait");
  1567. +   asm ("movl 12(%ebp),%eax");
  1568. +   asm ("fstpt (%eax)");
  1569. +   asm ("fwait");
  1570. + }
  1571. + 
  1572. + struct env387 
  1573. + {
  1574. +   unsigned int control;
  1575. +   unsigned int status;
  1576. +   unsigned int tag;
  1577. +   unsigned long eip;
  1578. +   unsigned short code_seg;
  1579. +   unsigned short operand_seg;
  1580. +   unsigned long opcode;
  1581. +   unsigned long operand;
  1582. +   unsigned char regs[8][10];
  1583. + };
  1584. + 
  1585. + static
  1586. + print_387_control_word (control)
  1587. + unsigned short control;
  1588. + {
  1589. +   printf ("control 0x%04x: ", control);
  1590. +   printf ("compute to ");
  1591. +   switch ((control >> 8) & 3) 
  1592. +     {
  1593. +     case 0: printf ("24 bits; "); break;
  1594. +     case 1: printf ("(bad); "); break;
  1595. +     case 2: printf ("53 bits; "); break;
  1596. +     case 3: printf ("64 bits; "); break;
  1597. +     }
  1598. +   printf ("round ");
  1599. +   switch ((control >> 10) & 3) 
  1600. +     {
  1601. +     case 0: printf ("NEAREST; "); break;
  1602. +     case 1: printf ("DOWN; "); break;
  1603. +     case 2: printf ("UP; "); break;
  1604. +     case 3: printf ("CHOP; "); break;
  1605. +     }
  1606. +   if (control & 0x3f) 
  1607. +     {
  1608. +       printf ("mask:");
  1609. +       if (control & 0x0001) printf (" INVALID");
  1610. +       if (control & 0x0002) printf (" DENORM");
  1611. +       if (control & 0x0004) printf (" DIVZ");
  1612. +       if (control & 0x0008) printf (" OVERF");
  1613. +       if (control & 0x0010) printf (" UNDERF");
  1614. +       if (control & 0x0020) printf (" LOS");
  1615. +       printf (";");
  1616. +     }
  1617. +   printf ("\n");
  1618. +   if (control & 0xe080) printf ("warning: reserved bits on 0x%x\n",
  1619. +                 control & 0xe080);
  1620. + }
  1621. + 
  1622. + static
  1623. + print_387_status_word (status)
  1624. +      unsigned short status;
  1625. + {
  1626. +   printf ("status 0x%04x: ", status);
  1627. +   if (status & 0xff) 
  1628. +     {
  1629. +       printf ("exceptions:");
  1630. +       if (status & 0x0001) printf (" INVALID");
  1631. +       if (status & 0x0002) printf (" DENORM");
  1632. +       if (status & 0x0004) printf (" DIVZ");
  1633. +       if (status & 0x0008) printf (" OVERF");
  1634. +       if (status & 0x0010) printf (" UNDERF");
  1635. +       if (status & 0x0020) printf (" LOS");
  1636. +       if (status & 0x0040) printf (" FPSTACK");
  1637. +       printf ("; ");
  1638. +     }
  1639. +   printf ("flags: %d%d%d%d; ",
  1640. +       (status & 0x4000) != 0,
  1641. +       (status & 0x0400) != 0,
  1642. +       (status & 0x0200) != 0,
  1643. +       (status & 0x0100) != 0);
  1644. +   
  1645. +   printf ("top %d\n", (status >> 11) & 7);
  1646. + }
  1647. + 
  1648. + static
  1649. + print_387_status (ep)
  1650. +      struct env387 *ep;
  1651. + {
  1652. +   int i;
  1653. +   int top;
  1654. +   int fpreg;
  1655. +   unsigned char *p;
  1656. +   
  1657. +   if (ep->status != 0) 
  1658. +       print_387_status_word (ep->status);
  1659. +   
  1660. +   print_387_control_word (ep->control);
  1661. +   printf ("last exception: ");
  1662. +   printf ("opcode 0x%x; ", ep->opcode);
  1663. +   printf ("pc 0x%x:0x%x; ", ep->code_seg, ep->eip);
  1664. +   printf ("operand 0x%x:0x%x\n", ep->operand_seg, ep->operand);
  1665. +   
  1666. +   top = (ep->status >> 11) & 7;
  1667. +   
  1668. +   printf ("regno  tag  msb              lsb  value\n");
  1669. +   for (fpreg = 7; fpreg >= 0; fpreg--) 
  1670. +     {
  1671. +       double val;
  1672. +       
  1673. +       printf ("%s %d: ", fpreg == top ? "=>" : "  ", fpreg);
  1674. +       
  1675. +       switch ((ep->tag >> (fpreg * 2)) & 3) 
  1676. +     {
  1677. +     case 0: printf ("valid "); break;
  1678. +     case 1: printf ("zero  "); break;
  1679. +     case 2: printf ("trap  "); break;
  1680. +     case 3: printf ("empty "); break;
  1681. +     }
  1682. +       for (i = 9; i >= 0; i--)
  1683. +     printf ("%02x", ep->regs[fpreg][i]);
  1684. +       
  1685. +       i387_to_double (ep->regs[fpreg], (char *)&val);
  1686. +       printf ("  %g\n", val);
  1687. +     }
  1688. + }
  1689. + 
  1690. + #ifndef U_FPSTATE
  1691. + #define U_FPSTATE(u) u.u_fps
  1692. + #endif
  1693. + 
  1694. + i386_float_info ()
  1695. + {
  1696. +   struct user u; /* just for address computations */
  1697. +   int i;
  1698. +   /* fpstate defined in <sys/user.h> */
  1699. +   struct u_fps *fpstatep;
  1700. +   char buf[sizeof (struct u_fps) + 2 * sizeof (int)];
  1701. +   unsigned int uaddr;
  1702. +   char fpvalid;
  1703. +   unsigned int rounded_addr;
  1704. +   unsigned int rounded_size;
  1705. +   extern int corechan;
  1706. +   int skip;
  1707. +   
  1708. +   uaddr = (char *)&u.u_fpsaved - (char *)&u;
  1709. +   if (have_inferior_p()) 
  1710. +     {
  1711. +       unsigned int data;
  1712. +       unsigned int mask;
  1713. +       
  1714. +       rounded_addr = uaddr & -sizeof (int);
  1715. +       data = ptrace (3, inferior_pid, rounded_addr, 0);
  1716. +       mask = 0xff << ((uaddr - rounded_addr) * 8);
  1717. +       
  1718. +       fpvalid = ((data & mask) != 0);
  1719. +     } 
  1720. +   else 
  1721. +     {
  1722. +       if (lseek (corechan, uaddr, 0) < 0)
  1723. +     perror ("seek on core file");
  1724. +       if (myread (corechan, &fpvalid, 1) < 0) 
  1725. +     perror ("read on core file");
  1726. +       
  1727. +     }
  1728. +   
  1729. +   if (fpvalid == 0) 
  1730. +     {
  1731. +       printf ("no floating point status saved\n");
  1732. +       return;
  1733. +     }
  1734. +   
  1735. +   uaddr = (char *)&U_FPSTATE(u) - (char *)&u;
  1736. +   if (have_inferior_p ()) 
  1737. +     {
  1738. +       int *ip;
  1739. +       
  1740. +       rounded_addr = uaddr & -sizeof (int);
  1741. +       rounded_size = (((uaddr + sizeof (struct u_fps)) - uaddr) +
  1742. +               sizeof (int) - 1) / sizeof (int);
  1743. +       skip = uaddr - rounded_addr;
  1744. +       
  1745. +       ip = (int *)buf;
  1746. +       for (i = 0; i < rounded_size; i++) 
  1747. +     {
  1748. +       *ip++ = ptrace (3, inferior_pid, rounded_addr, 0);
  1749. +       rounded_addr += sizeof (int);
  1750. +     }
  1751. +     } 
  1752. +   else 
  1753. +     {
  1754. +       if (lseek (corechan, uaddr, 0) < 0)
  1755. +     perror_with_name ("seek on core file");
  1756. +       if (myread (corechan, buf, sizeof (struct u_fps)) < 0) 
  1757. +     perror_with_name ("read from core file");
  1758. +       skip = 0;
  1759. +     }
  1760. +   
  1761. +   fpstatep = (struct u_fps *)(buf + skip);
  1762. +   print_387_status ((struct env387 *)fpstatep);
  1763. + }
  1764.