![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mappings.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / lib / old_compiler / dbx|
Return to mappings.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / lib / old_compiler / dbx |
1.1 root 1: /*
2: * Copyright (c) 1983 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: */
6:
7: #ifndef lint
8: static char sccsid[] = "@(#)mappings.c 5.3 (Berkeley) 1/12/88";
9: #endif not lint
10:
11: static char rcsid[] = "$Header: mappings.c,v 1.3 87/03/26 19:41:55 donn Exp $";
12:
13: /*
14: * Source-to-object and vice versa mappings.
15: */
16:
17: #include "defs.h"
18: #include "mappings.h"
19: #include "symbols.h"
20: #include "source.h"
21: #include "object.h"
22: #include "machine.h"
23:
24: #ifndef public
25: #include "machine.h"
26: #include "source.h"
27: #include "symbols.h"
28:
29: typedef struct {
30: Address addr;
31: String filename;
32: Lineno lineindex; /* index to first linetab entry */
33: } Filetab;
34:
35: typedef struct {
36: Lineno line;
37: Address addr;
38: } Linetab;
39:
40: Filetab *filetab;
41: Linetab *linetab;
42:
43: #define NOADDR ((Address) -1) /* no address for line or procedure */
44:
45: #endif
46:
47: /*
48: * Get the source file name associated with a given address.
49: */
50:
51: public String srcfilename(addr)
52: Address addr;
53: {
54: register Address i, j, k;
55: Address a;
56: Filetab *ftp;
57: String s;
58:
59: s = nil;
60: if (nlhdr.nfiles != 0 and addr >= filetab[0].addr) {
61: i = 0;
62: j = nlhdr.nfiles - 1;
63: while (i < j) {
64: k = (i + j) / 2;
65: ftp = &filetab[k];
66: a = ftp->addr;
67: if (a == addr) {
68: s = ftp->filename;
69: break;
70: } else if (addr > a) {
71: i = k + 1;
72: } else {
73: j = k - 1;
74: }
75: }
76: if (s == nil) {
77: if (addr >= filetab[i].addr) {
78: s = filetab[i].filename;
79: } else {
80: s = filetab[i-1].filename;
81: }
82: }
83: }
84: return s;
85: }
86:
87: /*
88: * Find the line associated with the given address.
89: * If the second parameter is true, then the address must match
90: * a source line exactly. Otherwise the nearest source line
91: * below the given address is returned.
92: *
93: * Return the index of the line table entry or -1 if none suitable.
94: */
95:
96: private integer findline (addr, exact)
97: Address addr;
98: Boolean exact;
99: {
100: register Address i, j, k;
101: register Lineno r;
102: register Address a;
103:
104: if (nlhdr.nlines == 0 or addr < linetab[0].addr) {
105: r = -1;
106: } else {
107: i = 0;
108: j = nlhdr.nlines - 1;
109: if (addr == linetab[i].addr) {
110: r = i;
111: } else if (addr == linetab[j].addr) {
112: r = j;
113: } else if (addr > linetab[j].addr) {
114: r = exact ? -1 : j;
115: } else {
116: do {
117: k = (i + j) div 2;
118: a = linetab[k].addr;
119: if (a == addr) break;
120: if (addr > a) {
121: i = k + 1;
122: } else {
123: j = k - 1;
124: }
125: } while (i <= j);
126: if (a == addr) {
127: r = k;
128: } else if (exact) {
129: r = -1;
130: } else if (addr > linetab[i].addr) {
131: r = i;
132: } else {
133: r = i - 1;
134: }
135: }
136: }
137: return r;
138: }
139:
140: /*
141: * Lookup the source line number nearest (from below) to an address.
142: *
143: * It is possible (unfortunately) that the compiler will generate
144: * code before line number for a procedure. Therefore we check
145: * to see that the found line is in the same procedure as the given address.
146: * If it isn't, then we walk forward until the first suitable line is found.
147: */
148:
149: public Lineno srcline (addr)
150: Address addr;
151: {
152: Lineno i, r;
153: Symbol f1, f2;
154: Address a;
155:
156: i = findline(addr, false);
157: if (i == -1) {
158: f1 = whatblock(addr);
159: if (f1 == nil or nosource(f1)) {
160: r = 0;
161: } else {
162: a = codeloc(f1);
163: for (;;) {
164: r = linelookup(a);
165: if (r != 0 or a >= CODESTART + objsize) {
166: break;
167: }
168: ++a;
169: }
170: }
171: } else {
172: r = linetab[i].line;
173: if (linetab[i].addr != addr) {
174: f1 = whatblock(addr);
175: if (nosource(f1)) {
176: r = 0;
177: } else {
178: f2 = whatblock(linetab[i].addr + 1);
179: if (f1 != f2) {
180: do {
181: ++i;
182: } while (linetab[i].addr < addr and i < nlhdr.nlines);
183: r = linetab[i].line;
184: }
185: }
186: }
187: }
188: return r;
189: }
190:
191: /*
192: * Look for a line exactly corresponding to the given address.
193: */
194:
195: public Lineno linelookup(addr)
196: Address addr;
197: {
198: integer i;
199: Lineno r;
200:
201: i = findline(addr, true);
202: if (i == -1) {
203: r = 0;
204: } else {
205: r = linetab[i].line;
206: }
207: return r;
208: }
209:
210: /*
211: * Lookup the object address of a given line from the named file.
212: *
213: * Potentially all files in the file table need to be checked
214: * until the line is found since a particular file name may appear
215: * more than once in the file table (caused by includes).
216: */
217:
218: public Address objaddr(line, name)
219: Lineno line;
220: String name;
221: {
222: register Filetab *ftp;
223: register Lineno i, j;
224: Boolean foundfile;
225:
226: if (nlhdr.nlines == 0) {
227: return NOADDR;
228: }
229: if (name == nil) {
230: name = cursource;
231: }
232: foundfile = false;
233: for (ftp = &filetab[0]; ftp < &filetab[nlhdr.nfiles]; ftp++) {
234: if (streq(ftp->filename, name)) {
235: foundfile = true;
236: i = ftp->lineindex;
237: if (ftp == &filetab[nlhdr.nfiles-1]) {
238: j = nlhdr.nlines;
239: } else {
240: j = (ftp + 1)->lineindex;
241: }
242: while (i < j) {
243: if (linetab[i].line == line) {
244: return linetab[i].addr;
245: }
246: i++;
247: }
248: }
249: }
250: if (not foundfile) {
251: error("source file \"%s\" not compiled with -g", name);
252: }
253: return NOADDR;
254: }
255:
256: /*
257: * Table for going from object addresses to the functions in which they belong.
258: */
259:
260: #define NFUNCS 500 /* initial size of function table */
261:
262: typedef struct {
263: Symbol func;
264: Address addr;
265: } AddrOfFunc;
266:
267: private AddrOfFunc *functab;
268: private int nfuncs = 0;
269: private int functablesize = 0;
270:
271: /*
272: * Insert a new function into the table.
273: */
274:
275: public newfunc(f, addr)
276: Symbol f;
277: Address addr;
278: {
279: register AddrOfFunc *af;
280: register int i;
281: AddrOfFunc *newfunctab;
282:
283: if (nfuncs >= functablesize) {
284: if (functablesize == 0) {
285: functab = newarr(AddrOfFunc, NFUNCS);
286: functablesize = NFUNCS;
287: } else {
288: functablesize *= 2;
289: newfunctab = newarr(AddrOfFunc, functablesize);
290: bcopy(functab, newfunctab, nfuncs * sizeof(AddrOfFunc));
291: dispose(functab);
292: functab = newfunctab;
293: }
294: }
295: af = &functab[nfuncs];
296: af->func = f;
297: af->addr = addr;
298: ++nfuncs;
299: }
300:
301: /*
302: * Return the function that begins at the given address.
303: */
304:
305: public Symbol whatblock(addr)
306: Address addr;
307: {
308: register int i, j, k;
309: Address a;
310:
311: i = 0;
312: j = nfuncs - 1;
313: if (addr < functab[i].addr) {
314: return program;
315: } else if (addr == functab[i].addr) {
316: return functab[i].func;
317: } else if (addr >= functab[j].addr) {
318: return functab[j].func;
319: }
320: while (i <= j) {
321: k = (i + j) / 2;
322: a = functab[k].addr;
323: if (a == addr) {
324: return functab[k].func;
325: } else if (addr > a) {
326: i = k+1;
327: } else {
328: j = k-1;
329: }
330: }
331: if (addr > functab[i].addr) {
332: return functab[i].func;
333: } else {
334: return functab[i-1].func;
335: }
336: /* NOTREACHED */
337: }
338:
339: /*
340: * Order the functab.
341: */
342:
343: private int cmpfunc(f1, f2)
344: AddrOfFunc *f1, *f2;
345: {
346: register Address a1, a2;
347:
348: a1 = (*f1).addr;
349: a2 = (*f2).addr;
350: return ( (a1 < a2) ? -1 : ( (a1 == a2) ? 0 : 1 ) );
351: }
352:
353: public ordfunctab()
354: {
355: qsort(functab, nfuncs, sizeof(AddrOfFunc), cmpfunc);
356: }
357:
358: /*
359: * Clear out the functab, used when re-reading the object information.
360: */
361:
362: public clrfunctab()
363: {
364: nfuncs = 0;
365: }
366:
367: public dumpfunctab()
368: {
369: int i;
370:
371: for (i = 0; i < nfuncs; i++) {
372: psym(functab[i].func);
373: }
374: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.