![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to symtab.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / gdb|
Return to symtab.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / gdb |
1.1 root 1: /* Symbol table lookup for the GNU debugger, GDB.
2: Copyright (C) 1986, 1987, 1988 Free Software Foundation, Inc.
3:
4: GDB is distributed in the hope that it will be useful, but WITHOUT ANY
5: WARRANTY. No author or distributor accepts responsibility to anyone
6: for the consequences of using it or for whether it serves any
7: particular purpose or works at all, unless he says so in writing.
8: Refer to the GDB General Public License for full details.
9:
10: Everyone is granted permission to copy, modify and redistribute GDB,
11: but only under the conditions described in the GDB General Public
12: License. A copy of this license is supposed to have been given to you
13: along with GDB so you can know your rights and responsibilities. It
14: should be in a file named COPYING. Among other things, the copyright
15: notice and this notice must be preserved on all copies.
16:
17: In other words, go ahead and share GDB, but don't try to stop
18: anyone else from sharing it farther. Help stamp out software hoarding!
19: */
20:
21: #include "defs.h"
22: #include "initialize.h"
23: #include "symtab.h"
24: #include "param.h"
25:
26: #include <stdio.h>
27: #include <obstack.h>
28:
29: START_FILE
30:
31: /* Allocate an obstack to hold objects that should be freed
32: when we load a new symbol table.
33: This includes the symbols made by dbxread
34: and the types that are not permanent. */
35:
36: struct obstack obstack1;
37:
38: struct obstack *symbol_obstack = &obstack1;
39:
40: /* These variables point to the objects
41: representing the predefined C data types. */
42:
43: struct type *builtin_type_void;
44: struct type *builtin_type_char;
45: struct type *builtin_type_short;
46: struct type *builtin_type_int;
47: struct type *builtin_type_long;
48: struct type *builtin_type_unsigned_char;
49: struct type *builtin_type_unsigned_short;
50: struct type *builtin_type_unsigned_int;
51: struct type *builtin_type_unsigned_long;
52: struct type *builtin_type_float;
53: struct type *builtin_type_double;
54:
55: /* Lookup the symbol table of a source file named NAME. */
56:
57: struct symtab *
58: lookup_symtab (name)
59: char *name;
60: {
61: register struct symtab *s;
62: register char *copy;
63:
64: for (s = symtab_list; s; s = s->next)
65: if (!strcmp (name, s->filename))
66: return s;
67:
68: /* If name not found as specified, see if adding ".c" helps. */
69:
70: copy = (char *) alloca (strlen (name) + 3);
71: strcpy (copy, name);
72: strcat (copy, ".c");
73: for (s = symtab_list; s; s = s->next)
74: if (!strcmp (copy, s->filename))
75: return s;
76:
77: return 0;
78: }
79:
80: /* Lookup a typedef or primitive type named NAME,
81: visible in lexical block BLOCK.
82: If NOERR is nonzero, return zero if NAME is not suitably defined. */
83:
84: struct type *
85: lookup_typename (name, block, noerr)
86: char *name;
87: struct block *block;
88: int noerr;
89: {
90: register struct symbol *sym = lookup_symbol (name, block, VAR_NAMESPACE);
91: if (sym == 0 || SYMBOL_CLASS (sym) != LOC_TYPEDEF)
92: {
93: if (!strcmp (name, "int"))
94: return builtin_type_int;
95: if (!strcmp (name, "long"))
96: return builtin_type_long;
97: if (!strcmp (name, "short"))
98: return builtin_type_short;
99: if (!strcmp (name, "char"))
100: return builtin_type_char;
101: if (!strcmp (name, "float"))
102: return builtin_type_float;
103: if (!strcmp (name, "double"))
104: return builtin_type_double;
105: if (!strcmp (name, "void"))
106: return builtin_type_void;
107:
108: if (noerr)
109: return 0;
110: error ("No type named %s.", name);
111: }
112: return SYMBOL_TYPE (sym);
113: }
114:
115: struct type *
116: lookup_unsigned_typename (name)
117: char *name;
118: {
119: if (!strcmp (name, "int"))
120: return builtin_type_unsigned_int;
121: if (!strcmp (name, "long"))
122: return builtin_type_unsigned_long;
123: if (!strcmp (name, "short"))
124: return builtin_type_unsigned_short;
125: if (!strcmp (name, "char"))
126: return builtin_type_unsigned_char;
127: error ("No type named unsigned %s.", name);
128: }
129:
130: /* Lookup a structure type named "struct NAME",
131: visible in lexical block BLOCK. */
132:
133: struct type *
134: lookup_struct (name, block)
135: char *name;
136: struct block *block;
137: {
138: register struct symbol *sym = lookup_symbol (name, block, STRUCT_NAMESPACE);
139: if (sym == 0)
140: error ("No struct type named %s.", name);
141: if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
142: error ("This context has union or enum %s, not a struct.", name);
143: return SYMBOL_TYPE (sym);
144: }
145:
146: /* Lookup a union type named "union NAME",
147: visible in lexical block BLOCK. */
148:
149: struct type *
150: lookup_union (name, block)
151: char *name;
152: struct block *block;
153: {
154: register struct symbol *sym = lookup_symbol (name, block, STRUCT_NAMESPACE);
155: if (sym == 0)
156: error ("No union type named %s.", name);
157: if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_UNION)
158: error ("This context has struct or enum %s, not a union.", name);
159: return SYMBOL_TYPE (sym);
160: }
161:
162: /* Lookup an enum type named "enum NAME",
163: visible in lexical block BLOCK. */
164:
165: struct type *
166: lookup_enum (name, block)
167: char *name;
168: struct block *block;
169: {
170: register struct symbol *sym = lookup_symbol (name, block, STRUCT_NAMESPACE);
171: if (sym == 0)
172: error ("No enum type named %s.", name);
173: if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_ENUM)
174: error ("This context has struct or union %s, not an enum.", name);
175: return SYMBOL_TYPE (sym);
176: }
177:
178: /* Given a type TYPE, return a type of pointers to that type.
179: May need to construct such a type if this is the first use. */
180:
181: struct type *
182: lookup_pointer_type (type)
183: struct type *type;
184: {
185: register struct type *ptype = TYPE_POINTER_TYPE (type);
186: if (ptype) return ptype;
187:
188: /* This is the first time anyone wanted a pointer to a TYPE. */
189: if (TYPE_FLAGS (type) & TYPE_FLAG_PERM)
190: ptype = (struct type *) xmalloc (sizeof (struct type));
191: else
192: ptype = (struct type *) obstack_alloc (symbol_obstack,
193: sizeof (struct type));
194:
195: bzero (ptype, sizeof (struct type));
196: TYPE_TARGET_TYPE (ptype) = type;
197: TYPE_POINTER_TYPE (type) = ptype;
198: /* New type is permanent if type pointed to is permanent. */
199: if (TYPE_FLAGS (type) & TYPE_FLAG_PERM)
200: TYPE_FLAGS (ptype) |= TYPE_FLAG_PERM;
201: /* We assume the machine has only one representation for pointers! */
202: TYPE_LENGTH (ptype) = sizeof (char *);
203: TYPE_CODE (ptype) = TYPE_CODE_PTR;
204: return ptype;
205: }
206:
207: /* Given a type TYPE, return a type of functions that return that type.
208: May need to construct such a type if this is the first use. */
209:
210: struct type *
211: lookup_function_type (type)
212: struct type *type;
213: {
214: register struct type *ptype = TYPE_FUNCTION_TYPE (type);
215: if (ptype) return ptype;
216:
217: /* This is the first time anyone wanted a function returning a TYPE. */
218: if (TYPE_FLAGS (type) & TYPE_FLAG_PERM)
219: ptype = (struct type *) xmalloc (sizeof (struct type));
220: else
221: ptype = (struct type *) obstack_alloc (symbol_obstack,
222: sizeof (struct type));
223:
224: bzero (ptype, sizeof (struct type));
225: TYPE_TARGET_TYPE (ptype) = type;
226: TYPE_FUNCTION_TYPE (type) = ptype;
227: /* New type is permanent if type returned is permanent. */
228: if (TYPE_FLAGS (type) & TYPE_FLAG_PERM)
229: TYPE_FLAGS (ptype) |= TYPE_FLAG_PERM;
230: TYPE_LENGTH (ptype) = 1;
231: TYPE_CODE (ptype) = TYPE_CODE_FUNC;
232: TYPE_NFIELDS (ptype) = 0;
233: return ptype;
234: }
235:
236: /* Smash TYPE to be a type of pointers to TO_TYPE.
237: If TO_TYPE is not permanent and has no pointer-type yet,
238: record TYPE as its pointer-type. */
239:
240: void
241: smash_to_pointer_type (type, to_type)
242: struct type *type, *to_type;
243: {
244: bzero (type, sizeof (struct type));
245: TYPE_TARGET_TYPE (type) = to_type;
246: /* We assume the machine has only one representation for pointers! */
247: TYPE_LENGTH (type) = sizeof (char *);
248: TYPE_CODE (type) = TYPE_CODE_PTR;
249:
250: if (TYPE_POINTER_TYPE (to_type) == 0
251: && !(TYPE_FLAGS (type) & TYPE_FLAG_PERM))
252: {
253: TYPE_POINTER_TYPE (to_type) = type;
254: }
255: }
256:
257: /* Smash TYPE to be a type of functions returning TO_TYPE.
258: If TO_TYPE is not permanent and has no function-type yet,
259: record TYPE as its function-type. */
260:
261: void
262: smash_to_function_type (type, to_type)
263: struct type *type, *to_type;
264: {
265: bzero (type, sizeof (struct type));
266: TYPE_TARGET_TYPE (type) = to_type;
267: TYPE_LENGTH (type) = 1;
268: TYPE_CODE (type) = TYPE_CODE_FUNC;
269: TYPE_NFIELDS (type) = 0;
270:
271: if (TYPE_FUNCTION_TYPE (to_type) == 0
272: && !(TYPE_FLAGS (type) & TYPE_FLAG_PERM))
273: {
274: TYPE_FUNCTION_TYPE (to_type) = type;
275: }
276: }
277:
278: static struct symbol *lookup_block_symbol ();
279:
280: /* Find the definition for a specified symbol name NAME
281: in namespace NAMESPACE, visible from lexical block BLOCK.
282: Returns the struct symbol pointer, or zero if no symbol is found. */
283:
284: struct symbol *
285: lookup_symbol (name, block, namespace)
286: char *name;
287: register struct block *block;
288: enum namespace namespace;
289: {
290: register int i, n;
291: register struct symbol *sym;
292: register struct symtab *s;
293: struct blockvector *bv;
294:
295: /* Search specified block and its superiors. */
296:
297: while (block != 0)
298: {
299: sym = lookup_block_symbol (block, name, namespace);
300: if (sym) return sym;
301: block = BLOCK_SUPERBLOCK (block);
302: }
303:
304: /* Now search all symtabs' global blocks. */
305:
306: for (s = symtab_list; s; s = s->next)
307: {
308: bv = BLOCKVECTOR (s);
309: block = BLOCKVECTOR_BLOCK (bv, 0);
310: sym = lookup_block_symbol (block, name, namespace);
311: if (sym) return sym;
312: }
313:
314: /* Now search all symtabs' per-file blocks.
315: Not strictly correct, but more useful than an error. */
316:
317: for (s = symtab_list; s; s = s->next)
318: {
319: bv = BLOCKVECTOR (s);
320: block = BLOCKVECTOR_BLOCK (bv, 1);
321: sym = lookup_block_symbol (block, name, namespace);
322: if (sym) return sym;
323: }
324: return 0;
325: }
326:
327: /* Look for a symbol in block BLOCK. */
328:
329: static struct symbol *
330: lookup_block_symbol (block, name, namespace)
331: register struct block *block;
332: char *name;
333: enum namespace namespace;
334: {
335: register int bot, top, inc;
336: register struct symbol *sym;
337:
338: top = BLOCK_NSYMS (block);
339: bot = 0;
340:
341: /* If the blocks's symbols were sorted, start with a binary search. */
342:
343: if (BLOCK_SHOULD_SORT (block))
344: {
345: /* First, advance BOT to not far before
346: the first symbol whose name is NAME. */
347:
348: while (1)
349: {
350: inc = (top - bot + 1);
351: /* No need to keep binary searching for the last few bits worth. */
352: if (inc < 4)
353: break;
354: inc = (inc >> 1) + bot;
355: sym = BLOCK_SYM (block, inc);
356: if (SYMBOL_NAME (sym)[0] < name[0])
357: bot = inc;
358: else if (SYMBOL_NAME (sym)[0] > name[0])
359: top = inc;
360: else if (strcmp (SYMBOL_NAME (sym), name) < 0)
361: bot = inc;
362: else
363: top = inc;
364: }
365:
366: /* Now scan forward until we run out of symbols,
367: find one whose name is greater than NAME,
368: or find one we want.
369: If there is more than one symbol with the right name and namespace,
370: we return the first one. dbxread.c is careful to make sure
371: that if one is a register then it comes first. */
372:
373: top = BLOCK_NSYMS (block);
374: while (bot < top)
375: {
376: sym = BLOCK_SYM (block, bot);
377: inc = SYMBOL_NAME (sym)[0] - name[0];
378: if (inc == 0)
379: inc = strcmp (SYMBOL_NAME (sym), name);
380: if (inc == 0 && SYMBOL_NAMESPACE (sym) == namespace)
381: return sym;
382: if (inc > 0)
383: return 0;
384: bot++;
385: }
386: return 0;
387: }
388:
389: /* Here if block isn't sorted.
390: This loop is equivalent to the loop above,
391: but hacked greatly for speed. */
392:
393: top = BLOCK_NSYMS (block);
394: inc = name[0];
395: while (bot < top)
396: {
397: sym = BLOCK_SYM (block, bot);
398: if (SYMBOL_NAME (sym)[0] == inc
399: && !strcmp (SYMBOL_NAME (sym), name)
400: && SYMBOL_NAMESPACE (sym) == namespace)
401: return sym;
402: bot++;
403: }
404: return 0;
405: }
406:
407: /* Return the symbol for the function which contains a specified
408: lexical block, described by a struct block BL. */
409:
410: struct symbol *
411: block_function (bl)
412: struct block *bl;
413: {
414: while (BLOCK_FUNCTION (bl) == 0 && BLOCK_SUPERBLOCK (bl) != 0)
415: bl = BLOCK_SUPERBLOCK (bl);
416:
417: return BLOCK_FUNCTION (bl);
418: }
419:
420: /* Subroutine of find_pc_line */
421:
422: static struct symtab *
423: find_pc_symtab (pc)
424: register CORE_ADDR pc;
425: {
426: register struct block *b;
427: struct blockvector *bv;
428: register struct symtab *s;
429:
430: /* Search all symtabs for one whose file contains our pc */
431:
432: for (s = symtab_list; s; s = s->next)
433: {
434: bv = BLOCKVECTOR (s);
435: b = BLOCKVECTOR_BLOCK (bv, 0);
436: if (BLOCK_START (b) <= pc
437: && BLOCK_END (b) > pc)
438: break;
439: }
440:
441: return s;
442: }
443:
444: /* Find the source file and line number for a given PC value.
445: Return a structure containing a symtab pointer, a line number,
446: and a pc range for the entire source line.
447: The value's .pc field is NOT the specified pc.
448: NOTCURRENT nonzero means, if specified pc is on a line boundary,
449: use the line that ends there. Otherwise, in that case, the line
450: that begins there is used. */
451:
452: struct symtab_and_line
453: find_pc_line (pc, notcurrent)
454: CORE_ADDR pc;
455: int notcurrent;
456: {
457: struct symtab *s;
458: register struct linetable *l;
459: register int len;
460: register int i, item;
461: int line;
462: struct symtab_and_line value;
463: struct blockvector *bv;
464:
465: /* Info on best line seen so far, and where it starts, and its file. */
466:
467: int best_line = 0;
468: CORE_ADDR best_pc = 0;
469: CORE_ADDR best_end = 0;
470: struct symtab *best_symtab = 0;
471:
472: /* Store here the first line number
473: of a file which contains the line at the smallest pc after PC.
474: If we don't find a line whose range contains PC,
475: we will use a line one less than this,
476: with a range from the start of that file to the first line's pc. */
477: int alt_line = 0;
478: CORE_ADDR alt_pc = 0;
479: struct symtab *alt_symtab = 0;
480:
481: /* Info on best line seen in this file. */
482:
483: int prev_line;
484: CORE_ADDR prev_pc;
485:
486: /* Info on first line of this file. */
487:
488: int first_line;
489: CORE_ADDR first_pc;
490:
491: /* If this pc is not from the current frame,
492: it is the address of the end of a call instruction.
493: Quite likely that is the start of the following statement.
494: But what we want is the statement containing the instruction.
495: Fudge the pc to make sure we get that. */
496:
497: if (notcurrent) pc -= 1;
498:
499: s = find_pc_symtab (pc);
500: if (s == 0)
501: {
502: value.symtab = 0;
503: value.line = 0;
504: value.pc = pc;
505: return value;
506: }
507:
508: bv = BLOCKVECTOR (s);
509:
510: /* Look at all the symtabs that share this blockvector.
511: They all have the same apriori range, that we found was right;
512: but they have different line tables. */
513:
514: for (; s && BLOCKVECTOR (s) == bv; s = s->next)
515: {
516: /* Find the best line in this symtab. */
517: l = LINETABLE (s);
518: len = l->nitems;
519: prev_line = -1;
520: first_line = -1;
521: for (i = 0; i < len; i++)
522: {
523: item = l->item[i];
524: if (item < 0)
525: line = - item - 1;
526: else
527: {
528: line++;
529: if (first_line < 0)
530: {
531: first_line = line;
532: first_pc = item;
533: }
534: /* Return the last line that did not start after PC. */
535: if (pc >= item)
536: {
537: prev_line = line;
538: prev_pc = item;
539: }
540: else
541: break;
542: }
543: }
544:
545: /* Is this file's best line closer than the best in the other files?
546: If so, record this file, and its best line, as best so far. */
547: if (prev_line >= 0 && prev_pc > best_pc)
548: {
549: best_pc = prev_pc;
550: best_line = prev_line;
551: best_symtab = s;
552: if (i < len)
553: best_end = item;
554: else
555: best_end = 0;
556: }
557: /* Is this file's first line closer than the first lines of other files?
558: If so, record this file, and its first line, as best alternate. */
559: if (first_line >= 0 && first_pc > pc
560: && (alt_pc == 0 || first_pc < alt_pc))
561: {
562: alt_pc = first_pc;
563: alt_line = first_line;
564: alt_symtab = s;
565: }
566: }
567: if (best_symtab == 0)
568: {
569: value.symtab = alt_symtab;
570: value.line = alt_line - 1;
571: value.pc = BLOCK_END (BLOCKVECTOR_BLOCK (bv, 0));
572: value.end = alt_pc;
573: }
574: else
575: {
576: value.symtab = best_symtab;
577: value.line = best_line;
578: value.pc = best_pc;
579: value.end = (best_end ? best_end
580: : (alt_pc ? alt_pc
581: : BLOCK_END (BLOCKVECTOR_BLOCK (bv, 0))));
582: }
583: return value;
584: }
585:
586: /* Find the PC value for a given source file and line number.
587: Returns zero for invalid line number.
588: The source file is specified with a struct symtab. */
589:
590: CORE_ADDR
591: find_line_pc (symtab, line)
592: struct symtab *symtab;
593: int line;
594: {
595: register struct linetable *l;
596: register int index;
597: int dummy;
598:
599: if (symtab == 0)
600: return 0;
601: l = LINETABLE (symtab);
602: index = find_line_common(l, line, &dummy);
603: return index ? l->item[index] : 0;
604: }
605:
606: /* Find the range of pc values in a line.
607: Store the starting pc of the line into *STARTPTR
608: and the ending pc (start of next line) into *ENDPTR.
609: Returns 1 to indicate success.
610: Returns 0 if could not find the specified line. */
611:
612: int
613: find_line_pc_range (symtab, thisline, startptr, endptr)
614: struct symtab *symtab;
615: int thisline;
616: CORE_ADDR *startptr, *endptr;
617: {
618: register struct linetable *l;
619: register int index;
620: int exact_match; /* did we get an exact linenumber match */
621: register CORE_ADDR prev_pc;
622: CORE_ADDR last_pc;
623:
624: if (symtab == 0)
625: return 0;
626:
627: l = LINETABLE (symtab);
628: index = find_line_common (l, thisline, &exact_match);
629: if (index)
630: {
631: *startptr = l->item[index];
632: /* If we have not seen an entry for the specified line,
633: assume that means the specified line has zero bytes. */
634: if (!exact_match || index == l->nitems-1)
635: *endptr = *startptr;
636: else
637: /* Perhaps the following entry is for the following line.
638: It's worth a try. */
639: if (l->item[index+1] > 0)
640: *endptr = l->item[index+1];
641: else
642: *endptr = find_line_pc (symtab, thisline+1);
643: return 1;
644: }
645:
646: return 0;
647: }
648:
649: /* Given a line table and a line number, return the index into the line
650: table for the pc of the nearest line whose number is >= the specified one.
651: Return 0 if none is found. The value is never zero is it is an index.
652:
653: Set *EXACT_MATCH nonzero if the value returned is an exact match. */
654:
655: static int
656: find_line_common (l, lineno, exact_match)
657: register struct linetable *l;
658: register int lineno;
659: int *exact_match;
660: {
661: register int i;
662: register int len;
663:
664: /* BEST is the smallest linenumber > LINENO so far seen,
665: or 0 if none has been seen so far.
666: BEST_INDEX identifies the item for it. */
667:
668: int best_index = 0;
669: int best = 0;
670:
671: int nextline = -1;
672:
673: if (lineno <= 0)
674: return 0;
675:
676: len = l->nitems;
677: for (i = 0; i < len; i++)
678: {
679: register int item = l->item[i];
680:
681: if (item < 0)
682: nextline = - item - 1;
683: else
684: {
685: nextline++;
686: if (nextline == lineno)
687: {
688: *exact_match = 1;
689: return i;
690: }
691:
692: if (nextline > lineno && (best == 0 || nextline < best))
693: {
694: best = lineno;
695: best_index = i;
696: }
697: }
698: }
699:
700: /* If we got here, we didn't get an exact match. */
701:
702: *exact_match = 0;
703: return best_index;
704: }
705:
706: int
707: find_pc_line_pc_range (pc, startptr, endptr)
708: CORE_ADDR pc;
709: CORE_ADDR *startptr, *endptr;
710: {
711: struct symtab_and_line sal;
712: sal = find_pc_line (pc, 0);
713: *startptr = sal.pc;
714: *endptr = sal.end;
715: return sal.symtab != 0;
716: }
717:
718: /* Parse a string that specifies a line number.
719: Pass the address of a char * variable; that variable will be
720: advanced over the characters actually parsed.
721:
722: The string can be:
723:
724: LINENUM -- that line number in current file. PC returned is 0.
725: FILE:LINENUM -- that line in that file. PC returned is 0.
726: FUNCTION -- line number of openbrace of that function.
727: PC returned is the start of the function.
728: FILE:FUNCTION -- likewise, but prefer functions in that file.
729: *EXPR -- line in which address EXPR appears.
730:
731: FUNCTION may be an undebuggable function found in misc_function_vector.
732:
733: If the argument FUNFIRSTLINE is nonzero, we want the first line
734: of real code inside a function when a function is specified.
735:
736: DEFAULT_SYMTAB specifies the file to use if none is specified.
737: It defaults to current_source_symtab.
738: DEFAULT_LINE specifies the line number to use for relative
739: line numbers (that start with signs). Defaults to current_source_line.
740:
741: Note that it is possible to return zero for the symtab
742: if no file is validly specified. Callers must check that.
743: Also, the line number returned may be invalid. */
744:
745: struct symtab_and_line
746: decode_line_1 (argptr, funfirstline, default_symtab, default_line)
747: char **argptr;
748: int funfirstline;
749: struct symtab *default_symtab;
750: int default_line;
751: {
752: struct symtab_and_line value;
753: register char *p, *p1;
754: register struct symtab *s;
755: register struct symbol *sym;
756: register CORE_ADDR pc;
757: register int i;
758: char *copy;
759:
760: /* Defaults have defaults. */
761:
762: if (default_symtab == 0)
763: {
764: default_symtab = current_source_symtab;
765: default_line = current_source_line;
766: }
767:
768: /* See if arg is *PC */
769:
770: if (**argptr == '*')
771: {
772: (*argptr)++;
773: pc = parse_and_eval_address_1 (argptr);
774: value = find_pc_line (pc, 0);
775: value.pc = pc;
776: return value;
777: }
778:
779: /* Maybe arg is FILE : LINENUM or FILE : FUNCTION */
780:
781: s = 0;
782:
783: for (p = *argptr; *p; p++)
784: {
785: if (p[0] == ':' || p[0] == ' ' || p[0] == '\t')
786: break;
787: }
788: while (p[0] == ' ' || p[0] == '\t') p++;
789:
790: if (p[0] == ':')
791: {
792: /* Extract the file name. */
793: p1 = p;
794: while (p != *argptr && p[-1] == ' ') --p;
795: copy = (char *) alloca (p - *argptr + 1);
796: bcopy (*argptr, copy, p - *argptr);
797: copy[p - *argptr] = 0;
798:
799: /* Find that file's data. */
800: s = lookup_symtab (copy);
801: if (s == 0)
802: {
803: if (symtab_list == 0)
804: error ("No symbol table is loaded. Use the \"symbol-file\" command.");
805: error ("No source file named %s.", copy);
806: }
807:
808: /* Discard the file name from the arg. */
809: p = p1 + 1;
810: while (*p == ' ' || *p == '\t') p++;
811: *argptr = p;
812: }
813:
814: /* S is specified file's symtab, or 0 if no file specified.
815: arg no longer contains the file name. */
816:
817: /* Check whether arg is all digits (and sign) */
818:
819: p = *argptr;
820: if (*p == '-' || *p == '+') p++;
821: while (*p >= '0' && *p <= '9')
822: p++;
823:
824: if (p != *argptr && (*p == 0 || *p == ' ' || *p == '\t' || *p == ','))
825: {
826: /* We found a token consisting of all digits -- at least one digit. */
827: enum sign {none, plus, minus} sign = none;
828:
829: if (**argptr == '+')
830: sign = plus, (*argptr)++;
831: else if (**argptr == '-')
832: sign = minus, (*argptr)++;
833: value.line = atoi (*argptr);
834: switch (sign)
835: {
836: case plus:
837: if (p == *argptr)
838: value.line = 5;
839: if (s == 0)
840: value.line = default_line + value.line;
841: break;
842: case minus:
843: if (p == *argptr)
844: value.line = 15;
845: if (s == 0)
846: value.line = default_line - value.line;
847: else
848: value.line = 1;
849: break;
850: }
851:
852: while (*p == ' ' || *p == '\t') p++;
853: *argptr = p;
854: if (s == 0)
855: s = default_symtab;
856: value.symtab = s;
857: value.pc = 0;
858: return value;
859: }
860:
861: /* Arg token is not digits => try it as a function name
862: Find the next token (everything up to end or next whitespace). */
863: p = *argptr;
864: while (*p && *p != ' ' && *p != '\t' && *p != ',') p++;
865: copy = (char *) alloca (p - *argptr + 1);
866: bcopy (*argptr, copy, p - *argptr);
867: copy[p - *argptr] = 0;
868: while (*p == ' ' || *p == '\t') p++;
869: *argptr = p;
870:
871: /* Look up that token as a function.
872: If file specified, use that file's per-file block to start with. */
873:
874: sym = lookup_symbol (copy, s ? BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), 1) : 0,
875: VAR_NAMESPACE);
876:
877: if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
878: {
879: /* Arg is the name of a function */
880: pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) + FUNCTION_START_OFFSET;
881: if (funfirstline)
882: SKIP_PROLOGUE (pc);
883: value = find_pc_line (pc, 0);
884: value.pc = (value.end && value.pc != pc) ? value.end : pc;
885: return value;
886: }
887:
888: if (sym)
889: error ("%s is not a function.", copy);
890:
891: if ((i = lookup_misc_func (copy)) < 0)
892: error ("Function %s not defined.", copy);
893: else
894: {
895: value.symtab = 0;
896: value.line = 0;
897: value.pc = misc_function_vector[i].address + FUNCTION_START_OFFSET;
898: if (funfirstline)
899: SKIP_PROLOGUE (value.pc);
900: return value;
901: }
902:
903: if (symtab_list == 0)
904: error ("No symbol table is loaded. Use the \"symbol-file\" command.");
905: error ("Function %s not defined.", copy);
906: }
907:
908: struct symtab_and_line
909: decode_line_spec (string, funfirstline)
910: char *string;
911: int funfirstline;
912: {
913: struct symtab_and_line sal;
914: if (string == 0)
915: error ("Empty line specification.");
916: sal = decode_line_1 (&string, funfirstline,
917: current_source_symtab, current_source_line);
918: if (*string)
919: error ("Junk at end of line specification: %s", string);
920: return sal;
921: }
922:
923: /* Return the index of misc function named NAME. */
924:
925: static
926: lookup_misc_func (name)
927: register char *name;
928: {
929: register int i;
930:
931: for (i = 0; i < misc_function_count; i++)
932: if (!strcmp (misc_function_vector[i].name, name))
933: return i;
934: return -1; /* not found */
935: }
936:
937: static void
938: sources_info ()
939: {
940: register struct symtab *s;
941: register int column = 0;
942:
943: if (symtab_list == 0)
944: {
945: printf ("No symbol table is loaded.\n");
946: return;
947: }
948: printf ("Source files for which symbol table is known:\n");
949: for (s = symtab_list; s; s = s->next)
950: {
951: if (column != 0 && column + strlen (s->filename) >= 70)
952: {
953: printf ("\n");
954: column = 0;
955: }
956: else if (column != 0)
957: {
958: printf (" ");
959: column++;
960: }
961: printf ("%s", s->filename);
962: column += strlen (s->filename);
963: if (s->next)
964: {
965: printf (",");
966: column++;
967: }
968: }
969: printf ("\n");
970: }
971:
972: /* List all symbols (if REGEXP is 0) or all symbols matching REGEXP.
973: If CLASS is zero, list all symbols except functions and type names.
974: If CLASS is 1, list only functions.
975: If CLASS is 2, list only type names. */
976:
977: #define MORE \
978: { print_count++; \
979: if (print_count >= 21) \
980: { printf ("--Type Return to print more--"); \
981: print_count = 0; \
982: fflush (stdout); \
983: read_line (); } }
984:
985: static void sort_block_syms ();
986:
987: static void
988: list_symbols (regexp, class)
989: char *regexp;
990: int class;
991: {
992: register struct symtab *s;
993: register struct blockvector *bv;
994: struct blockvector *prev_bv = 0;
995: register struct block *b;
996: register int i, j;
997: register struct symbol *sym;
998: char *val;
999: int found_in_file;
1000: static char *classnames[]
1001: = {"variable", "function", "type"};
1002: int print_count = 0;
1003:
1004: if (regexp)
1005: if (val = (char *) re_comp (regexp))
1006: error ("Invalid regexp: %s", val);
1007:
1008: printf (regexp
1009: ? "All %ss matching regular expression \"%s\":\n"
1010: : "All defined %ss:\n",
1011: classnames[class],
1012: regexp);
1013:
1014: for (s = symtab_list; s; s = s->next)
1015: {
1016: found_in_file = 0;
1017: bv = BLOCKVECTOR (s);
1018: /* Often many files share a blockvector.
1019: Scan each blockvector only once so that
1020: we don't get every symbol many times.
1021: It happens that the first symtab in the list
1022: for any given blockvector is the main file. */
1023: if (bv != prev_bv)
1024: for (i = 0; i < 2; i++)
1025: {
1026: b = BLOCKVECTOR_BLOCK (bv, i);
1027: /* Skip the sort if this block is always sorted. */
1028: if (!BLOCK_SHOULD_SORT (b))
1029: sort_block_syms (b);
1030: for (j = 0; j < BLOCK_NSYMS (b); j++)
1031: {
1032: QUIT;
1033: sym = BLOCK_SYM (b, j);
1034: if ((regexp == 0 || re_exec (SYMBOL_NAME (sym)))
1035: && ((class == 0 && SYMBOL_CLASS (sym) != LOC_TYPEDEF
1036: && SYMBOL_CLASS (sym) != LOC_BLOCK)
1037: || (class == 1 && SYMBOL_CLASS (sym) == LOC_BLOCK)
1038: || (class == 2 && SYMBOL_CLASS (sym) == LOC_TYPEDEF)))
1039: {
1040: if (!found_in_file)
1041: {
1042: printf ("\nFile %s:\n", s->filename);
1043: print_count += 2;
1044: }
1045: found_in_file = 1;
1046: MORE;
1047: if (class != 2 && i == 1)
1048: printf ("static ");
1049: if (class == 2
1050: && SYMBOL_NAMESPACE (sym) != STRUCT_NAMESPACE)
1051: printf ("typedef ");
1052:
1053: type_print (SYMBOL_TYPE (sym),
1054: (SYMBOL_CLASS (sym) == LOC_TYPEDEF
1055: ? "" : SYMBOL_NAME (sym)),
1056: stdout, 0);
1057: if (class == 2
1058: && SYMBOL_NAMESPACE (sym) != STRUCT_NAMESPACE
1059: && (TYPE_NAME ((SYMBOL_TYPE (sym))) == 0
1060: || 0 != strcmp (TYPE_NAME ((SYMBOL_TYPE (sym))),
1061: SYMBOL_NAME (sym))))
1062: printf (" %s", SYMBOL_NAME (sym));
1063: printf (";\n");
1064: }
1065: }
1066: }
1067: prev_bv = bv;
1068: }
1069: }
1070:
1071: static void
1072: variables_info (regexp)
1073: char *regexp;
1074: {
1075: list_symbols (regexp, 0);
1076: }
1077:
1078: static void
1079: functions_info (regexp)
1080: char *regexp;
1081: {
1082: list_symbols (regexp, 1);
1083: }
1084:
1085: static void
1086: types_info (regexp)
1087: char *regexp;
1088: {
1089: list_symbols (regexp, 2);
1090: }
1091:
1092: /* Call sort_block_syms to sort alphabetically the symbols of one block. */
1093:
1094: static int
1095: compare_symbols (s1, s2)
1096: struct symbol **s1, **s2;
1097: {
1098: /* Names that are less should come first. */
1099: register int namediff = strcmp (SYMBOL_NAME (*s1), SYMBOL_NAME (*s2));
1100: if (namediff != 0) return namediff;
1101: /* For symbols of the same name, registers should come first. */
1102: return ((SYMBOL_CLASS (*s2) == LOC_REGISTER)
1103: - (SYMBOL_CLASS (*s1) == LOC_REGISTER));
1104: }
1105:
1106: static void
1107: sort_block_syms (b)
1108: register struct block *b;
1109: {
1110: qsort (&BLOCK_SYM (b, 0), BLOCK_NSYMS (b),
1111: sizeof (struct symbol *), compare_symbols);
1112: }
1113:
1114: /* Initialize the standard C scalar types. */
1115:
1116: static
1117: struct type *
1118: init_type (code, length, uns, name)
1119: enum type_code code;
1120: int length, uns;
1121: char *name;
1122: {
1123: register struct type *type;
1124:
1125: type = (struct type *) xmalloc (sizeof (struct type));
1126: bzero (type, sizeof *type);
1127: TYPE_CODE (type) = code;
1128: TYPE_LENGTH (type) = length;
1129: TYPE_FLAGS (type) = uns ? TYPE_FLAG_UNSIGNED : 0;
1130: TYPE_FLAGS (type) |= TYPE_FLAG_PERM;
1131: TYPE_NFIELDS (type) = 0;
1132: TYPE_NAME (type) = name;
1133:
1134: return type;
1135: }
1136:
1137: static
1138: initialize ()
1139: {
1140: add_info ("variables", variables_info,
1141: "All global and static variable names, or those matching REGEXP.");
1142: add_info ("functions", functions_info,
1143: "All function names, or those matching REGEXP.");
1144: add_info ("types", types_info,
1145: "All types names, or those matching REGEXP.");
1146: add_info ("sources", sources_info,
1147: "Source files in the program.");
1148:
1149: obstack_init (symbol_obstack);
1150:
1151: builtin_type_void = init_type (TYPE_CODE_VOID, 0, 0, "void");
1152:
1153: builtin_type_float = init_type (TYPE_CODE_FLT, sizeof (float), 0, "float");
1154: builtin_type_double = init_type (TYPE_CODE_FLT, sizeof (double), 0, "double");
1155:
1156: builtin_type_char = init_type (TYPE_CODE_INT, sizeof (char), 0, "char");
1157: builtin_type_short = init_type (TYPE_CODE_INT, sizeof (short), 0, "short");
1158: builtin_type_long = init_type (TYPE_CODE_INT, sizeof (long), 0, "long");
1159: builtin_type_int = init_type (TYPE_CODE_INT, sizeof (int), 0, "int");
1160:
1161: builtin_type_unsigned_char = init_type (TYPE_CODE_INT, sizeof (char), 1, "unsigned char");
1162: builtin_type_unsigned_short = init_type (TYPE_CODE_INT, sizeof (short), 1, "unsigned short");
1163: builtin_type_unsigned_long = init_type (TYPE_CODE_INT, sizeof (long), 1, "unsigned long");
1164: builtin_type_unsigned_int = init_type (TYPE_CODE_INT, sizeof (int), 1, "unsigned int");
1165: }
1166:
1167: END_FILE
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.