![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dlout.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 / kernel / tools|
Return to dlout.c CVS log | Up to [MW Coherent from dump] / coherent / b / kernel / tools |
1.1 root 1: /*
2: * File: dlout.c
3: *
4: * Purpose: Display contents of l.out file intelligibly.
5: *
6: * $Log: dlout.c,v $
7: * Revision 1.1 93/04/16 07:01:40 bin
8: * Initial revision
9: *
10: */
11:
12: /*
13: * ----------------------------------------------------------------------
14: * Includes.
15: */
16: #include <canon.h>
17: #include <l.out.h>
18: #include <stdio.h>
19: #include <sys/reg.h>
20: #include <sys/uproc.h>
21:
22: /*
23: * ----------------------------------------------------------------------
24: * Definitions.
25: * Constants.
26: * Macros with argument lists.
27: * Typedefs.
28: * Enums.
29: */
30: #define DSIZE 16
31:
32: struct seg_info {
33: int si_base;
34: int si_size;
35: long si_offset;
36: };
37:
38: /*
39: * ----------------------------------------------------------------------
40: * Functions.
41: * Import Functions.
42: * Export Functions.
43: * Local Functions.
44: */
45:
46: /*
47: * ----------------------------------------------------------------------
48: * Global Data.
49: * Import Variables.
50: * Export Variables.
51: * Local Variables.
52: */
53: static char * cmd;
54: static struct ldheader ldHead;
55: static char * loutName = NULL;
56: static FILE * fp;
57: static char *segName[NUSEG] = {
58: "USER", "TEXT", "DATA", "STACK"
59: };
60: static struct seg_info segInfo[NUSEG];
61:
62: /*
63: * ----------------------------------------------------------------------
64: * Code.
65: */
66:
67: void
68: usage()
69: {
70: fprintf(stderr, "Usage: %s l.out-file\n", cmd);
71: exit(1);
72: }
73:
74: /*
75: * Given text name and vital stats for a segment, do a hex dump.
76: */
77: void
78: dumpseg(name, infop)
79: char *name;
80: struct seg_info *infop;
81: {
82: unsigned char coredata[DSIZE];
83: unsigned char savedata[DSIZE];
84: int segOffset;
85: int i;
86: /*
87: * sameState:
88: * -1 just starting; don't look for matching display lines
89: * 0 current line does not match previous line
90: * 1 current line matches previous line
91: * 2 current line matches previous 2 or more lines
92: */
93: int sameState = -1;
94: int doPrint, match;
95:
96: /* make sure we can seek to start of segment */
97: if (fseek(fp, infop->si_offset, 0) < 0) {
98: fprintf(stderr, "Can't seek to %s segment!\n", name);
99: exit(1);
100: }
101:
102: printf("\nContents of %s segment:\n", name);
103: for (segOffset = 0; segOffset < infop->si_size; segOffset += DSIZE) {
104: int readLen = DSIZE;
105: int remains = infop->si_size - segOffset;
106:
107: if (readLen > remains)
108: readLen = remains;
109:
110: if (fread(coredata, readLen, 1, fp) !=1) {
111: fprintf(stderr, "Can't read core data.\n");
112: exit(1);
113: }
114:
115: /* always display last line of segment */
116: if (remains <= DSIZE)
117: match = 1;
118: else
119: match = memcmp(coredata, savedata, DSIZE);
120:
121: switch(sameState) {
122: case -1:
123: sameState = 0;
124: doPrint = 1;
125: break;
126: case 0:
127: if (match) {
128: doPrint = 1;
129: } else {
130: sameState = 1;
131: doPrint = 0;
132: }
133: break;
134: case 1:
135: if (match) {
136: doPrint = 1;
137: sameState = 0;
138: } else {
139: sameState = 2;
140: doPrint = 0;
141: printf(" *\n");
142: }
143: break;
144: case 2:
145: if (match) {
146: doPrint = 1;
147: sameState = 0;
148: } else {
149: doPrint = 0;
150: }
151: break;
152: }
153: if (doPrint) {
154: printf("%06X", segOffset);
155: for (i = 0; i < readLen; i++)
156: printf(" %02X", coredata[i]);
157: printf("\n");
158: }
159: memcpy(savedata, coredata, DSIZE);
160: }
161: }
162:
163: /*
164: * Once the file has been opened and magic number checked, this function
165: * does the work.
166: *
167: * Globals used: fp, chInfo.
168: */
169: void
170: dlout()
171: {
172: int i;
173: unsigned int shrds; /* size of shared data */
174:
175: /* canonicalize where necessary */
176: canint(ldHead.l_machine);
177: if (ldHead.l_machine!=M_8086) {
178: fprintf(stderr, "Wrong machine.\n");
179: exit(1);
180: }
181:
182: for (i=0; i<NXSEG; i++) {
183: cansize(ldHead.l_ssize[i]);
184: }
185: canint(ldHead.l_flag);
186: canvaddr(ldHead.l_entry);
187:
188: /* display shared/unshared */
189: if (ldHead.l_flag & LF_SHR)
190: printf("shared executable\n");
191: else
192: printf("nonshared executable\n");
193:
194:
195: /* display entry point */
196: printf("entry point = %04X\n", ldHead.l_entry);
197:
198: /* fetch segment data */
199: segInfo[SISTEXT].si_offset = sizeof(struct ldheader);
200: segInfo[SISTEXT].si_base = NBPS;
201: segInfo[SISTEXT].si_size = ldHead.l_ssize[L_SHRI];
202:
203: segInfo[SIPDATA].si_offset = sizeof(struct ldheader) +
204: segInfo[SISTEXT].si_size;
205: segInfo[SIPDATA].si_base = 0;
206: segInfo[SIPDATA].si_size = ldHead.l_ssize[L_SHRD] +
207: ldHead.l_ssize[L_PRVD];
208: if (ldHead.l_flag & LF_SHR) {
209: shrds = ldHead.l_ssize[L_SHRD];
210: printf("shrds = %04X\n", shrds);
211: }
212:
213: segInfo[SIBSS].si_offset = 0;
214: segInfo[SIBSS].si_base = segInfo[SIPDATA].si_size;
215: segInfo[SIBSS].si_size = ldHead.l_ssize[L_BSSD];
216:
217: /* display segment sizes */
218: printf("\nSegment\tBase\t\tSize\n");
219: for (i = 0; i < NUSEG; i++) {
220: if (i != SISTEXT && i != SIPDATA)
221: continue;
222: printf("%s\t%08x\t%08x\n",
223: segName[i], segInfo[i].si_base, segInfo[i].si_size);
224: }
225:
226: /* dump segments */
227: for (i = 0; i < NUSEG; i++) {
228: if (i != SISTEXT && i != SIPDATA)
229: continue;
230: dumpseg(segName[i], segInfo + i);
231: }
232: #if 0
233: long offset;
234: static struct uproc uProc;
235: static int regs[SS+1];
236: int i;
237: int base, size;
238:
239: /* display uproc version number */
240: offset = chInfo.ch_info_len + chInfo.ch_uproc_offset;
241: if (fseek(fp, offset, 0) < 0) {
242: fprintf(stderr, "Can't seek to uproc.\n");
243: exit(1);
244: }
245: if (fread(&uProc, sizeof(uProc), 1, fp) !=1) {
246: fprintf(stderr, "Can't read uproc.\n");
247: exit(1);
248: }
249: printf("uproc version = 0x%04x\n", uProc.u_version);
250:
251: #endif
252: }
253:
254: main(argc, argv)
255: int argc;
256: char *argv[];
257: {
258:
259: /* command line housekeeping */
260: cmd = argv[0];
261: if (argc != 2)
262: usage();
263: loutName = argv[1];
264:
265: /* try to open the l.out file for reading */
266: if ((fp = fopen(loutName, "r")) == NULL) {
267: fprintf(stderr, "Can't open %s for reading.\n", loutName);
268: exit(1);
269: }
270:
271: /* simple test for l.out file format */
272: if (fread(&ldHead, sizeof(ldHead), 1, fp) !=1) {
273: fprintf(stderr, "Can't read l.out header\n");
274: exit(1);
275: }
276:
277: if (ldHead.l_magic != L_MAGIC) {
278: fprintf(stderr, "Not a l.out file.\n");
279: exit(1);
280: }
281: printf("L.out file: %s\n", loutName);
282:
283: /* call a function to do the work */
284: dlout();
285:
286: /* cleanup */
287: fclose(fp);
288: exit(0);
289: }
290:
291: long
292: _canl(n)
293: int n;
294: {
295: return (n<<16)|((n>>16)&0xffff);
296: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.