![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to i8086a.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / bin / db_400|
Return to i8086a.c CVS log | Up to [MW Coherent from dump] / coherent / b / bin / db_400 |
1.1 root 1: /*
2: * i8086a.c
3: *
4: * The information contained herein is a trade secret of Mark Williams
5: * Company, and is confidential information. It is provided under a
6: * license agreement, and may be copied or disclosed only under the
7: * terms of that agreement. Any reproduction or disclosure of this
8: * material without the express written authorization of Mark Williams
9: * Company or persuant to the license agreement is unlawful.
10: *
11: * COHERENT Version 2.3.35
12: * Copyright (c) 1982, 1983, 1984.
13: * An unpublished work by Mark Williams Company, Chicago.
14: * All rights reserved.
15: */
16:
17: #include <stdio.h>
18: #include <sys/param.h>
19: #include <l.out.h>
20: #include <signal.h>
21: #include <sys/ptrace.h>
22: #include <sys/timeout.h>
23: #include <sys/uproc.h>
24: #include "trace.h"
25: #include "i8086.h"
26:
27: extern errno;
28:
29: #define MAGICTEST hdrinfo.magic == L_MAGIC
30:
31: /*
32: * Given an l.out header, set up segmentation for an l.out.
33: */
34: setaseg(ldhp)
35: register struct ldheader *ldhp;
36: {
37: register long fbase;
38: register long si;
39: register long pi;
40: register long bi;
41: register long sd;
42: register long pd;
43: register long rs;
44:
45: fbase = sizeof(*ldhp);
46: si = ldhp->l_ssize[L_SHRI];
47: pi = ldhp->l_ssize[L_PRVI];
48: bi = ldhp->l_ssize[L_BSSI];
49: sd = ldhp->l_ssize[L_SHRD];
50: pd = ldhp->l_ssize[L_PRVD];
51: switch (ldhp->l_flag & (LF_SEP|LF_SHR)) {
52: case 0:
53: endpure = NULL;
54: DSPACE = setsmap(NULL, (long)0, si+pi, fbase,
55: getf, putf, 0);
56: DSPACE = setsmap(DSPACE, si+pi+bi, sd+pd, fbase+si+pi,
57: getf, putf, 0);
58: ISPACE = DSPACE;
59: break;
60:
61: case LF_SHR:
62: endpure = NULL;
63: rs = (si+sd+0xF) & ~0xF;
64: DSPACE = setsmap(NULL, (long)0, si, fbase, getf, putf, 0);
65: DSPACE = setsmap(DSPACE, si, sd, fbase+si+pi, getf, putf, 0);
66: DSPACE = setsmap(DSPACE, rs, pi, fbase+si, getf, putf, 0);
67: DSPACE = setsmap(DSPACE, rs+pi, pd, fbase+si+pi+sd,
68: getf, putf, 0);
69: ISPACE = DSPACE;
70: break;
71:
72: case LF_SEP:
73: endpure = NULL;
74: ISPACE = setsmap(NULL, (long)0, si+pi, fbase, getf, putf, 0);
75: DSPACE = setsmap(NULL, (long)0, sd+pd, fbase+si+pi,
76: getf, putf, 0);
77: break;
78:
79: case LF_SEP|LF_SHR:
80: endpure = NULL; /* No pure data */
81: rs = (sd+0xF) & ~0xF;
82: ISPACE = setsmap(NULL, (long)0, si+pi, fbase, getf, putf, 0);
83: DSPACE = setsmap(NULL, (long)0, sd, fbase+si+pi, getf, putf, 0);
84: DSPACE = setsmap(DSPACE, rs, pd, fbase+si+pi+sd, getf, putf, 0);
85: break;
86: }
87: }
88:
89: /*
90: * Set up segmentation for kernel memory.
91: */
92: setkmem(np)
93: char *np;
94: {
95: register off_t l;
96: unsigned n;
97: struct LDSYM lds;
98:
99: cfp = openfil(np, rflag);
100: USPACE = setsmap(NULL, (off_t)0, (off_t)LI, (off_t)0,
101: getf, putf, 1);
102: add = 2;
103: if (getb(USEG, &n, sizeof(n)) == 0)
104: panic("Bad memory file");
105: l = (off_t)n << 4;
106: ISPACE = setsmap(NULL, (off_t)0, (off_t)LI, (off_t)l,
107: getf, putf, 1);
108: strncpy(lds.ls_id, "etext_", NCPLN);
109: if (nameval(&lds) == 0)
110: DSPACE = ISPACE;
111: else {
112: n = (lds.ls_addr+0xF) & ~0xF;
113: DSPACE = setsmap(NULL, (off_t)0, (off_t)LI, (off_t)l+n,
114: getf, putf, 1);
115: }
116: }
117:
118: /*
119: * Set up segmentation for a system dump.
120: */
121: setdump(np)
122: char *np;
123: {
124: setkmem(np);
125: }
126:
127: #if FPTEST
128: void
129: fpdump(fstp)
130: struct _fpstate * fstp;
131: {
132: int i;
133: int tagbits;
134: unsigned char opfirst, opsecond;
135: unsigned int fcs = fstp->cssel;
136: int tos = (fstp->sw >> 11) & 7;
137:
138: fflush(stdout);
139:
140: printf("fstp=%08x tos=%d ", fstp, tos);
141: opfirst = 0xD8 | ((fcs >> 24) & 7);
142: opsecond = fcs >> 16;
143: printf("cw=%04x sw=%04x tag=%04x\n",
144: fstp->cw&0xFFFF, fstp->sw&0xFFFF, fstp->tag&0xffff);
145: printf("op=%02x %02x fcs=%04x fip=%08x fos=%04x foo=%08x\n",
146: opfirst, opsecond,
147: fcs&0xFFFF, fstp->ipoff, fstp->datasel&0xFFFF, fstp->dataoff);
148: for (i = 0; i < 8; i++) {
149: tagbits = (fstp->tag >> (((tos + i) & 7) * 2)) & 3;
150: printf("st[%d]:(%d) at %08x ", i, tagbits,
151: fstp->_st + i);
152: switch(tagbits) {
153: case 0:
154: {
155: int j;
156: for (j = 0; j < 4; j++)
157: printf("%04x ", fstp->_st[i].significand[j]);
158: printf(":%04x ", fstp->_st[i].exponent);
159: }
160: printf("\n");
161: break;
162: case 1:
163: printf("Zero\n");
164: break;
165: case 2:
166: printf("Special: %08x %08x %08x %08x : %08x\n",
167: fstp->_st[i].significand[0],
168: fstp->_st[i].significand[1],
169: fstp->_st[i].significand[2],
170: fstp->_st[i].significand[3],
171: fstp->_st[i].exponent);
172: break;
173: case 3:
174: printf("Empty\n");
175: break;
176: }
177: }
178: fflush(stdout);
179: }
180: #endif
181:
182: /*
183: * Update register structure in memory.
184: */
185: setregs()
186: {
187: struct ureg ureg;
188:
189: regflag = 0;
190: add = 0; /* UGLY! FIX THIS! */
191: if (getb(USEG, (char *)&ureg, sizeof(ureg)) == 0) {
192: printr("Cannot read registers");
193: return 0;
194: }
195:
196: #if FPTEST
197: fpdump(&ureg.ur_fpstate);
198: #endif
199: copyreg(&ureg);
200: regflag = 1;
201: return 1;
202: }
203:
204: /*
205: * Copy registers from the User area structure to the register
206: * structure.
207: */
208: copyreg(up)
209: register struct ureg *up;
210: {
211: reg.r_ax = up->ur_ax;
212: reg.r_bx = up->ur_bx;
213: reg.r_cx = up->ur_cx;
214: reg.r_dx = up->ur_dx;
215: reg.r_sp = up->ur_sp;
216: reg.r_bp = up->ur_bp;
217: reg.r_si = up->ur_si;
218: reg.r_di = up->ur_di;
219: reg.r_cs = up->ur_cs;
220: reg.r_ds = up->ur_ds;
221: reg.r_ss = up->ur_ss;
222: reg.r_es = up->ur_es;
223: reg.r_ip = up->ur_ip;
224: reg.r_fw = up->ur_fw;
225: reg.r_fs = up->ur_fs;
226: reg.r_gs = up->ur_gs;
227: reg.valid = 1;
228: }
229:
230: /*
231: * If the given name matches a register, set up `ldp' with the address
232: * of a register in the user area.
233: */
234: regaddr(ldp)
235: struct LDSYM *ldp;
236: {
237: register char *cp;
238: register int c0;
239: register int c1;
240: register int a;
241:
242: a = 0; /* UGLY! FIX THIS */
243: cp = ldp->ls_id;
244: if ((c0=*cp++) == '\0')
245: return 0;
246: if ((c1=*cp++) == '\0')
247: return 0;
248: if (*cp != '\0')
249: return 0;
250: switch (c1) {
251: case 'h':
252: a++;
253: case 'l':
254: c1 = 'x';
255: }
256: cp = regitab;
257: do {
258: if (cp[0]==c0 && cp[1]==c1) {
259: ldp->ls_addr = a;
260: ldp->ls_type = L_REG;
261: return 1;
262: }
263: a += 2;
264: cp += 2;
265: } while (*cp != '\0');
266: return 0;
267: }
268:
269: /*
270: * Return the program counter.
271: */
272: caddr_t
273: getpc()
274: {
275: return reg.r_ip;
276: }
277:
278: /*
279: * Set the program counter.
280: */
281: setpc(ip)
282: caddr_t ip;
283: {
284: fprintf(stderr, "setpc(%x)\n", ip);
285: reg.r_ip = ip;
286: add = PTRACE_EIP;
287: putb(USEG, ®.r_ip, sizeof(reg.r_ip));
288: }
289:
290: /*
291: * Return the frame pointer.
292: */
293: getfp()
294: {
295: return reg.r_bp;
296: }
297:
298: /*
299: * Print out a constant in a reasonable format.
300: */
301: concons(sp, l)
302: register char *sp;
303: unsigned long l;
304: {
305: /* Another bug in unsigned long on the PDP11
306: if (l < 0x10)
307: */
308: if ((unsigned)l < 0x10)
309: sprintf(sp, "%d", (int)l);
310: else
311: sprintf(sp, "0x%lx", l);
312: }
313:
314: /*
315: * Display registers.
316: */
317: dispreg()
318: {
319: if (testint())
320: return;
321: if (hdrinfo.defsegatt == DSA16)
322: printf("%%ip=%04x %%fw=%04x\n", reg.r_ip, reg.r_fw);
323: else
324: printf("%%eip=%08x %%efw=%08x\n", reg.r_ip, reg.r_fw);
325:
326: if (testint())
327: return;
328: if (hdrinfo.defsegatt == DSA16)
329: printf("%%ax=%08x %%bx=%08x %%cx=%08x %%dx=%08x\n",
330: reg.r_ax, reg.r_bx, reg.r_cx, reg.r_dx);
331: else
332: printf("%%eax=%08x %%ebx=%08x %%ecx=%08x %%edx=%08x\n",
333: reg.r_ax, reg.r_bx, reg.r_cx, reg.r_dx);
334:
335: if (testint())
336: return;
337: if (hdrinfo.defsegatt == DSA16)
338: printf("%%sp=%08x %%bp=%08x %%si=%08x %%di=%08x\n",
339: reg.r_sp, reg.r_bp, reg.r_si, reg.r_di);
340: else
341: printf("%%esp=%08x %%ebp=%08x %%esi=%08x %%edi=%08x\n",
342: reg.r_sp, reg.r_bp, reg.r_si, reg.r_di);
343:
344: if (testint())
345: return;
346: printf("%%cs=%04x %%ds=%04x %%ss=%04x %%es=%04x %%fs=%04x %%gs=%04x\n",
347: reg.r_cs&0xffff, reg.r_ds&0xffff, reg.r_ss&0xffff,
348: reg.r_es&0xffff, reg.r_fs&0xffff, reg.r_gs&0xffff);
349: }
350:
351: /*
352: * Stack traceback.
353: */
354: dispsbt(l)
355: {
356: register int argc;
357: register int iflag;
358: register int sflag;
359: register int qflag;
360: unsigned amain;
361: unsigned int pc;
362: unsigned int rpc;
363: unsigned int fp;
364: unsigned int n;
365: unsigned char e[1];
366: unsigned char b[3];
367: struct LDSYM ldsym;
368:
369: amain = 1;
370: strcpy(ldsym.ls_id, MAGICTEST ? "main_" : "main");
371: if (nameval(&ldsym) != 0)
372: amain = ldsym.ls_addr;
373: add = MAGICTEST ? (unsigned short)reg.r_ip : reg.r_ip;
374: if (getb(ISEG, b, 1) == 0) {
375: printe("Illegal ip");
376: return;
377: }
378: sflag = 0;
379: fp = reg.r_bp;
380: e[0] = MAGICTEST ? 0x56 : 0xc8; /* push si : enter */
381: if (valname(1, (off_t)reg.r_ip, &ldsym) != 0) {
382: add = (long)ldsym.ls_addr;
383: getb(ISEG, (char *)e, 1);
384: }
385: if ( MAGICTEST ? (b[0]==0x56 || e[0]!=0x56) /* push si */
386: : (b[0]==0xc8 || e[0]!=0xc8) ) { /* enter */
387: sflag = 1;
388: fp = reg.r_sp - (MAGICTEST ? 6 : 4);
389: }
390: pc = reg.r_ip;
391: qflag = 0;
392: for (;;) {
393: add = MAGICTEST ? (unsigned short)fp + 6 : fp + 4;
394: if (getb(DSEG, &rpc, MAGICTEST ? 2 : 4) == 0)
395: break;
396: argc = 0;
397: add = MAGICTEST ? (unsigned short)rpc : rpc;
398: if (getb(ISEG, b, 3) != 0) {
399: if (b[0]==0x83 && b[1]==0xC4) /* add sp,$? */
400: argc = b[2]/(MAGICTEST ? 2 : 4);
401: }
402: add = MAGICTEST ? (unsigned short)rpc - 3 : rpc - 5;
403: if (getb(ISEG, b, 1) == 0)
404: break;
405: if (getb(ISEG, &n, (MAGICTEST ? 2 : 4)) == 0)
406: break;
407: printx(DAFMT, (long)fp);
408: printx(" ");
409: printx(DAFMT, (long)pc);
410: printx(" ");
411: if (b[0] == 0xE8) { /* call ? */
412: n += MAGICTEST ? (unsigned short) rpc : rpc;
413: putaddr(1, (long)n, I);
414: if (n == amain) {
415: qflag = 1;
416: argc = 3;
417: }
418: } else {
419: if (valname(1, (off_t)pc, &ldsym) == 0)
420: printx("*");
421: else {
422: printx("%.*s", NCPLN, ldsym.ls_id);
423: if (strcmp(ldsym.ls_id
424: , MAGICTEST ? "main_" : "main") == 0) {
425: qflag = 1;
426: argc = 3;
427: }
428: }
429: }
430: putx('(');
431: iflag = 0;
432: add = (MAGICTEST ? (unsigned short)fp : fp) + 8;
433: /* offset 8 coincidently works for both file formats */
434: while (argc--) {
435: if (getb(DSEG, &n, MAGICTEST ? 2 : 4) == 0)
436: break;
437: if (iflag++ != 0)
438: printx(", ");
439: putaddr(1, (long)n, -1);
440: }
441: printx(")\n");
442: if (testint())
443: return;
444: if (qflag)
445: break;
446: if (sflag) {
447: sflag = 0;
448: fp = reg.r_bp;
449: } else {
450: add = MAGICTEST ? (unsigned short)fp : fp;
451: if (getb(DSEG, &fp, (MAGICTEST ? 2 : 4)) == 0)
452: break;
453: }
454: if (--l == 0)
455: return;
456: pc = MAGICTEST ? (unsigned short)rpc : rpc;
457: }
458: }
459:
460: /*
461: * Get the return pc and frame pointer to set a return breakpoint.
462: */
463: setretf(pcp, fpp)
464: register caddr_t *pcp;
465: register caddr_t *fpp;
466: {
467: unsigned char b[1];
468:
469: add = reg.r_ip;
470: if (getb(ISEG, b, sizeof(b)) == 0)
471: return 0;
472: if (b[0] == 0x56) { /* push si */
473: *fpp = reg.r_bp;
474: add = reg.r_sp;
475: } else {
476: add = reg.r_bp;
477: if (getb(DSEG, (char *)fpp, sizeof(*fpp)) == 0)
478: return 0;
479: add = reg.r_bp + 6;
480: }
481: if (getb(DSEG, (char *)pcp, sizeof(*pcp)) == 0)
482: return 0;
483: }
484:
485: /*
486: * Initialise after getting a trap.
487: */
488: trapint()
489: {
490: caddr_t pc;
491: caddr_t fw;
492:
493: #if 0
494: /* new trap handler clears TF in PSW */
495: add = PTRACE_EFL;
496: if (getb(USEG, &fw, sizeof(int)) == 0) {
497: printr("Cannot get psw");
498: return 0;
499: }
500: fw &= ~TBIT;
501: add = PTRACE_EFL;
502: if (putb(USEG, &fw, sizeof(int)) == 0) {
503: printr("Cannot set psw");
504: return 0;
505: }
506: #endif
507: if (sysflag) {
508: add = PTRACE_EIP;
509: if (getb(USEG, &pc, sizeof(pc)) == 0) {
510: printr("Cannot get eip");
511: return 0;
512: }
513: pc -= 2;
514: add = PTRACE_EIP;
515: if (putb(USEG, &pc, sizeof(pc)) == 0) {
516: printr("Cannot set eip");
517: return 0;
518: }
519: add = (long)pc;
520: if (putb(ISEG, (char *)sin, sizeof(sin)) == 0) {
521: printr("Cannot set sin");
522: return 0;
523: }
524: bitflag = 1;
525: }
526: return 1;
527: }
528:
529: /*
530: * Set up before returning from a trap. Single stepping over a system
531: * call is handled here.
532: */
533: restret()
534: {
535: unsigned char w[1];
536:
537: sysflag = 0;
538: if (bitflag == 0)
539: return 1;
540: add = reg.r_ip;
541: if (getb(ISEG, (char *)w, sizeof(w)) == 0)
542: return 1;
543:
544: /* FIX THIS FOR 386 */
545: if (w[0] != 0xCD) /* Interrupt (system call) */
546: return 1;
547: add = reg.r_ip + 2;
548: if (getb(ISEG, (char *)sin, sizeof(sin)) == 0) {
549: printr("Cannot get breakpoint");
550: return 0;
551: }
552: add -= sizeof(sin);
553: if (putb(ISEG, (char *)bin, sizeof(bin)) == 0) {
554: printr("Cannot set breakpoint");
555: return 0;
556: }
557: bitflag = 0;
558: sysflag = 1;
559: return 1;
560: }
561:
562: /*
563: * Change sinmode to SCSET if instruction at EIP is a call.
564: */
565: setcont()
566: {
567: unsigned char w[4];
568: int xx;
569:
570: add = reg.r_ip;
571: if (getb(ISEG, &xx, sizeof(xx)) == 0) {
572: return;
573: }
574: w[0] = xx & 0xff;
575: w[1] = (xx>>8) & 0xff;
576: if (w[0] == 0xE8) { /* Direct call */
577: sinmode = SCSET;
578: }
579: if (w[0]==0xFF && (w[1]&0x38)==0x10) { /* Indirect call */
580: sinmode = SCSET;
581: }
582: }
583:
584: /*
585: * Get return address from ESP and set BSIN breakpoint there.
586: */
587: intcont()
588: {
589: unsigned return_addr;
590:
591: add = reg.r_sp;
592: if (getb(DSEG, &return_addr, sizeof(return_addr))) {
593: setibpt(BSIN, return_addr, reg.r_bp, NULL);
594: }
595: }
596:
597: /*
598: * See if the given instruction is a breakpoint.
599: */
600: testbpt(pc)
601: {
602: unsigned char w[1];
603:
604: add = pc;
605: return (getb(ISEG, w, sizeof(w))!=0 && w[0]==0xCC);
606: }
607:
608: /*
609: * Read `n' characters into the buffer `bp' starting at address `a'
610: * from the traced process, segment `f'.
611: */
612: getp(f, a, bp, n)
613: long a;
614: register char *bp;
615: register int n;
616: {
617: int d, n1;
618: char *memcpy();
619: int pcmd;
620:
621: for (errno = 0; n; n -= n1, a += n1, bp += n1) {
622: n1 =n>sizeof(long) ? sizeof(long) : n;
623: switch(f) {
624: case ISEG: pcmd = PTRACE_RD_TXT; break;
625: case DSEG: pcmd = PTRACE_RD_DAT; break;
626: case USEG: pcmd = PTRACE_RD_USR; break;
627: }
628: d = ptrace(pcmd, pid, (int *) a, 0);
629: if (errno)
630: return 0;
631: memcpy(bp, &d, n1);
632: }
633: return 1;
634: }
635:
636: /*
637: * Write `n' characters from the buffer `bp' starting at address `a' in
638: * the traced process to segment `f'.
639: */
640: putp(f, a, bp, n)
641: long a;
642: register char *bp;
643: register int n;
644: {
645: int d, n1;
646: int pcmd;
647:
648: for (errno = 0; n; n -= n1, a += n1, bp += n1) {
649: if (n < sizeof(long)) {
650: n1 = n;
651: switch(f) {
652: case ISEG: pcmd = PTRACE_RD_TXT; break;
653: case DSEG: pcmd = PTRACE_RD_DAT; break;
654: case USEG: pcmd = PTRACE_RD_USR; break;
655: }
656: d = ptrace(pcmd, pid, (int *)a, 0);
657: } else
658: n1 = sizeof(long);
659: memcpy(&d, bp, n1);
660: switch(f) {
661: case ISEG: pcmd = PTRACE_WR_TXT; break;
662: case DSEG: pcmd = PTRACE_WR_DAT; break;
663: case USEG: pcmd = PTRACE_WR_USR; break;
664: }
665: ptrace(pcmd, pid, (int *) a, d);
666: if (errno) {
667: perror("db: putp()");
668: return 0;
669: }
670: }
671: return 1;
672: }
673:
674: /******************************************************************************
675: *
676: * Note some #defines in these include files interferes with
677: * items in preceeding include files. Hence the strange
678: * program order.
679: *
680: ******************************************************************************/
681:
682: #include <coff.h>
683:
684: /*
685: * Given an l.out header, set up segmentation for an l.out.
686: */
687: setcoffseg(fp, coffhp)
688: FILE *fp;
689: FILEHDR *coffhp;
690: {
691: off_t fbase, tbase, tsize, dbase, dsize, bbase, bsize;
692: off_t f_tscnp, f_dscnp, f_bscnp;
693: SCNHDR *scnhp;
694: short i;
695:
696: if (coffhp->f_opthdr)
697: fbase = sizeof(FILEHDR) + coffhp->f_opthdr;
698: else
699: fbase = sizeof (FILEHDR);
700: if ( (scnhp=nalloc(coffhp->f_nscns*sizeof(SCNHDR))) == NULL ) {
701: printf("No memory to alloc to coff.h section headers");
702: return;
703: }
704:
705: fseek(fp, fbase, 0);
706: for (i=0; i<coffhp->f_nscns; scnhp++, i++) {
707: if (fread(scnhp, sizeof(SCNHDR), 1, fp) != 1)
708: printf("Cannot read coff.h section headers");
709:
710: switch((int)scnhp->s_flags) {
711: case STYP_TEXT:
712: tbase = scnhp->s_vaddr;
713: tsize = scnhp->s_size;
714: f_tscnp = scnhp->s_scnptr;
715: break;
716: case STYP_DATA:
717: dbase = scnhp->s_vaddr;
718: dsize = scnhp->s_size;
719: f_dscnp = scnhp->s_scnptr;
720: break;
721: case STYP_BSS:
722: bbase = scnhp->s_vaddr;
723: bsize = scnhp->s_size;
724: f_bscnp = scnhp->s_scnptr;
725: break;
726: default:
727: continue;
728: }
729: }
730:
731: #if 0 /* Assume NOT separate */
732: endpure = NULL;
733: DSPACE = setsmap(NULL, tbase, tsize, f_tscnp, getf, putf, 0);
734: /* dbase = (dbase + (off_t)0xF) & ~(off_t)0xF;
735: */ DSPACE = setsmap(DSPACE, dbase, dsize, f_dscnp, getf, putf, 0);
736: DSPACE = setsmap(DSPACE, bbase, bsize+4L, f_bscnp, getf, putf, 0);
737: ISPACE = DSPACE;
738:
739: #else /* Assume separate */
740: endpure = NULL;
741: ISPACE = setsmap(NULL, tbase, tsize, f_tscnp, getf, putf, 0);
742: /* dbase = (dbase + (off_t)0xF) & ~(off_t)0xF;
743: */ DSPACE = setsmap(NULL, dbase, dsize, f_dscnp, getf, putf, 0);
744: DSPACE = setsmap(DSPACE, bbase, bsize+4L, f_bscnp, getf, putf, 0);
745: #endif
746: nfree(scnhp);
747: }
748:
749: /* end of i8086a.c */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.