1 /* Symbol table lookup for the GNU debugger, GDB.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
31 #include "call-cmds.h"
33 #include "expression.h"
40 #include <sys/types.h>
46 /* Prototypes for local functions */
49 find_methods PARAMS ((struct type *, char *, struct symbol **));
52 completion_list_add_name PARAMS ((char *, char *, int, char *, char *));
55 build_canonical_line_spec PARAMS ((struct symtab_and_line *, char *, char ***));
57 static struct symtabs_and_lines
58 decode_line_2 PARAMS ((struct symbol *[], int, int, char ***));
61 rbreak_command PARAMS ((char *, int));
64 types_info PARAMS ((char *, int));
67 functions_info PARAMS ((char *, int));
70 variables_info PARAMS ((char *, int));
73 sources_info PARAMS ((char *, int));
76 list_symbols PARAMS ((char *, int, int));
79 output_source_filename PARAMS ((char *, int *));
82 operator_chars PARAMS ((char *, char **));
85 find_line_common PARAMS ((struct linetable *, int, int *));
87 static struct partial_symbol *
88 lookup_partial_symbol PARAMS ((struct partial_symtab *, const char *,
89 int, enum namespace));
91 static struct symtab *
92 lookup_symtab_1 PARAMS ((char *));
96 /* The single non-language-specific builtin type */
97 struct type *builtin_type_error;
99 /* Block in which the most recently searched-for symbol was found.
100 Might be better to make this a parameter to lookup_symbol and
103 const struct block *block_found;
105 char no_symtab_msg[] = "No symbol table is loaded. Use the \"file\" command.";
107 /* While the C++ support is still in flux, issue a possibly helpful hint on
108 using the new command completion feature on single quoted demangled C++
109 symbols. Remove when loose ends are cleaned up. FIXME -fnf */
112 cplusplus_hint (name)
115 printf ("Hint: try '%s<TAB> or '%s<ESC-?>\n", name, name);
116 printf ("(Note leading single quote.)\n");
119 /* Check for a symtab of a specific name; first in symtabs, then in
120 psymtabs. *If* there is no '/' in the name, a match after a '/'
121 in the symtab filename will also work. */
123 static struct symtab *
124 lookup_symtab_1 (name)
127 register struct symtab *s;
128 register struct partial_symtab *ps;
129 register char *slash;
130 register struct objfile *objfile;
134 /* First, search for an exact match */
136 ALL_SYMTABS (objfile, s)
137 if (STREQ (name, s->filename))
140 slash = strchr (name, '/');
142 /* Now, search for a matching tail (only if name doesn't have any dirs) */
145 ALL_SYMTABS (objfile, s)
147 char *p = s -> filename;
148 char *tail = strrchr (p, '/');
157 /* Same search rules as above apply here, but now we look thru the
160 ALL_PSYMTABS (objfile, ps)
161 if (STREQ (name, ps -> filename))
165 ALL_PSYMTABS (objfile, ps)
167 char *p = ps -> filename;
168 char *tail = strrchr (p, '/');
182 error ("Internal: readin %s pst for `%s' found when no symtab found.",
183 ps -> filename, name);
185 s = PSYMTAB_TO_SYMTAB (ps);
190 /* At this point, we have located the psymtab for this file, but
191 the conversion to a symtab has failed. This usually happens
192 when we are looking up an include file. In this case,
193 PSYMTAB_TO_SYMTAB doesn't return a symtab, even though one has
194 been created. So, we need to run through the symtabs again in
195 order to find the file.
196 XXX - This is a crock, and should be fixed inside of the the
197 symbol parsing routines. */
201 /* Lookup the symbol table of a source file named NAME. Try a couple
202 of variations if the first lookup doesn't work. */
208 register struct symtab *s;
211 s = lookup_symtab_1 (name);
214 /* If name not found as specified, see if adding ".c" helps. */
216 copy = (char *) alloca (strlen (name) + 3);
219 s = lookup_symtab_1 (copy);
222 /* We didn't find anything; die. */
226 /* Lookup the partial symbol table of a source file named NAME. This
227 only returns true on an exact match (ie. this semantics are
228 different from lookup_symtab. */
230 struct partial_symtab *
231 lookup_partial_symtab (name)
234 register struct partial_symtab *pst;
235 register struct objfile *objfile;
237 ALL_PSYMTABS (objfile, pst)
239 if (STREQ (name, pst -> filename))
247 /* Demangle a GDB method stub type.
248 Note that this function is g++ specific. */
251 gdb_mangle_name (type, i, j)
255 int mangled_name_len;
257 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
258 struct fn_field *method = &f[j];
259 char *field_name = TYPE_FN_FIELDLIST_NAME (type, i);
260 char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
261 char *newname = type_name_no_tag (type);
262 int is_constructor = STREQ (field_name, newname);
263 int is_destructor = is_constructor && DESTRUCTOR_PREFIX_P (physname);
264 /* Need a new type prefix. */
265 char *const_prefix = method->is_const ? "C" : "";
266 char *volatile_prefix = method->is_volatile ? "V" : "";
268 #ifndef GCC_MANGLE_BUG
269 int len = strlen (newname);
273 mangled_name = (char*) xmalloc(strlen(physname)+1);
274 strcpy(mangled_name, physname);
278 sprintf (buf, "__%s%s%d", const_prefix, volatile_prefix, len);
279 mangled_name_len = ((is_constructor ? 0 : strlen (field_name))
284 /* Only needed for GNU-mangled names. ANSI-mangled names
285 work with the normal mechanisms. */
286 if (OPNAME_PREFIX_P (field_name))
288 char *opname = cplus_mangle_opname (field_name + 3, 0);
290 error ("No mangling for \"%s\"", field_name);
291 mangled_name_len += strlen (opname);
292 mangled_name = (char *)xmalloc (mangled_name_len);
294 strncpy (mangled_name, field_name, 3);
295 mangled_name[3] = '\0';
296 strcat (mangled_name, opname);
300 mangled_name = (char *)xmalloc (mangled_name_len);
302 mangled_name[0] = '\0';
304 strcpy (mangled_name, field_name);
306 strcat (mangled_name, buf);
307 strcat (mangled_name, newname);
317 sprintf (buf, "__%s%s", const_prefix, volatile_prefix);
320 mangled_name_len = ((is_constructor ? 0 : strlen (field_name))
321 + strlen (buf) + strlen (physname) + 1);
323 /* Only needed for GNU-mangled names. ANSI-mangled names
324 work with the normal mechanisms. */
325 if (OPNAME_PREFIX_P (field_name))
327 opname = cplus_mangle_opname (field_name + 3, 0);
330 error ("No mangling for \"%s\"", field_name);
332 mangled_name_len += strlen (opname);
333 mangled_name = (char *) xmalloc (mangled_name_len);
335 strncpy (mangled_name, field_name, 3);
336 strcpy (mangled_name + 3, opname);
340 mangled_name = (char *) xmalloc (mangled_name_len);
343 mangled_name[0] = '\0';
347 strcpy (mangled_name, field_name);
350 strcat (mangled_name, buf);
353 strcat (mangled_name, physname);
354 return (mangled_name);
358 /* Find which partial symtab on contains PC. Return 0 if none. */
360 struct partial_symtab *
362 register CORE_ADDR pc;
364 register struct partial_symtab *pst;
365 register struct objfile *objfile;
367 ALL_PSYMTABS (objfile, pst)
369 if (pc >= pst->textlow && pc < pst->texthigh)
375 /* Find which partial symbol within a psymtab contains PC. Return 0
376 if none. Check all psymtabs if PSYMTAB is 0. */
377 struct partial_symbol *
378 find_pc_psymbol (psymtab, pc)
379 struct partial_symtab *psymtab;
382 struct partial_symbol *best, *p;
386 psymtab = find_pc_psymtab (pc);
390 best_pc = psymtab->textlow - 1;
392 for (p = psymtab->objfile->static_psymbols.list + psymtab->statics_offset;
393 (p - (psymtab->objfile->static_psymbols.list + psymtab->statics_offset)
394 < psymtab->n_static_syms);
396 if (SYMBOL_NAMESPACE (p) == VAR_NAMESPACE
397 && SYMBOL_CLASS (p) == LOC_BLOCK
398 && pc >= SYMBOL_VALUE_ADDRESS (p)
399 && SYMBOL_VALUE_ADDRESS (p) > best_pc)
401 best_pc = SYMBOL_VALUE_ADDRESS (p);
404 if (best_pc == psymtab->textlow - 1)
410 /* Find the definition for a specified symbol name NAME
411 in namespace NAMESPACE, visible from lexical block BLOCK.
412 Returns the struct symbol pointer, or zero if no symbol is found.
413 If SYMTAB is non-NULL, store the symbol table in which the
414 symbol was found there, or NULL if not found.
415 C++: if IS_A_FIELD_OF_THIS is nonzero on entry, check to see if
416 NAME is a field of the current implied argument `this'. If so set
417 *IS_A_FIELD_OF_THIS to 1, otherwise set it to zero.
418 BLOCK_FOUND is set to the block in which NAME is found (in the case of
419 a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */
422 lookup_symbol (name, block, namespace, is_a_field_of_this, symtab)
424 register const struct block *block;
425 const enum namespace namespace;
426 int *is_a_field_of_this;
427 struct symtab **symtab;
429 register struct symbol *sym;
430 register struct symtab *s;
431 register struct partial_symtab *ps;
432 struct blockvector *bv;
433 register struct objfile *objfile;
434 register struct block *b;
435 register struct minimal_symbol *msymbol;
437 extern char *gdb_completer_word_break_characters;
439 /* Search specified block and its superiors. */
443 sym = lookup_block_symbol (block, name, namespace);
449 /* Search the list of symtabs for one which contains the
450 address of the start of this block. */
451 ALL_SYMTABS (objfile, s)
453 bv = BLOCKVECTOR (s);
454 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
455 if (BLOCK_START (b) <= BLOCK_START (block)
456 && BLOCK_END (b) > BLOCK_START (block))
465 block = BLOCK_SUPERBLOCK (block);
468 /* FIXME: this code is never executed--block is always NULL at this
469 point. What is it trying to do, anyway? We already should have
470 checked the STATIC_BLOCK above (it is the superblock of top-level
471 blocks). Why is VAR_NAMESPACE special-cased? */
472 /* Don't need to mess with the psymtabs; if we have a block,
473 that file is read in. If we don't, then we deal later with
474 all the psymtab stuff that needs checking. */
475 if (namespace == VAR_NAMESPACE && block != NULL)
478 /* Find the right symtab. */
479 ALL_SYMTABS (objfile, s)
481 bv = BLOCKVECTOR (s);
482 b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
483 if (BLOCK_START (b) <= BLOCK_START (block)
484 && BLOCK_END (b) > BLOCK_START (block))
486 sym = lookup_block_symbol (b, name, VAR_NAMESPACE);
499 /* C++: If requested to do so by the caller,
500 check to see if NAME is a field of `this'. */
501 if (is_a_field_of_this)
503 struct value *v = value_of_this (0);
505 *is_a_field_of_this = 0;
506 if (v && check_field (v, name))
508 *is_a_field_of_this = 1;
515 /* Now search all global blocks. Do the symtab's first, then
516 check the psymtab's */
518 ALL_SYMTABS (objfile, s)
520 bv = BLOCKVECTOR (s);
521 block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
522 sym = lookup_block_symbol (block, name, namespace);
532 /* Check for the possibility of the symbol being a global function
533 that is stored in one of the minimal symbol tables. Eventually, all
534 global symbols might be resolved in this way. */
536 if (namespace == VAR_NAMESPACE)
538 msymbol = lookup_minimal_symbol (name, (struct objfile *) NULL);
541 s = find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol));
542 /* If S is NULL, there are no debug symbols for this file.
543 Skip this stuff and check for matching static symbols below. */
546 bv = BLOCKVECTOR (s);
547 block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
548 sym = lookup_block_symbol (block, SYMBOL_NAME (msymbol),
550 /* We kept static functions in minimal symbol table as well as
551 in static scope. We want to find them in the symbol table. */
553 block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
554 sym = lookup_block_symbol (block, SYMBOL_NAME (msymbol),
558 /* sym == 0 if symbol was found in the minimal symbol table
559 but not in the symtab.
560 Return 0 to use the msymbol definition of "foo_".
562 This happens for Fortran "foo_" symbols,
563 which are "foo" in the symtab.
565 This can also happen if "asm" is used to make a
566 regular symbol but not a debugging symbol, e.g.
578 ALL_PSYMTABS (objfile, ps)
580 if (!ps->readin && lookup_partial_symbol (ps, name, 1, namespace))
582 s = PSYMTAB_TO_SYMTAB(ps);
583 bv = BLOCKVECTOR (s);
584 block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
585 sym = lookup_block_symbol (block, name, namespace);
587 error ("Internal: global symbol `%s' found in %s psymtab but not in symtab", name, ps->filename);
594 /* Now search all per-file blocks.
595 Not strictly correct, but more useful than an error.
596 Do the symtabs first, then check the psymtabs */
598 ALL_SYMTABS (objfile, s)
600 bv = BLOCKVECTOR (s);
601 block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
602 sym = lookup_block_symbol (block, name, namespace);
612 ALL_PSYMTABS (objfile, ps)
614 if (!ps->readin && lookup_partial_symbol (ps, name, 0, namespace))
616 s = PSYMTAB_TO_SYMTAB(ps);
617 bv = BLOCKVECTOR (s);
618 block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
619 sym = lookup_block_symbol (block, name, namespace);
621 error ("Internal: static symbol `%s' found in %s psymtab but not in symtab", name, ps->filename);
628 /* Now search all per-file blocks for static mangled symbols.
629 Do the symtabs first, then check the psymtabs. */
631 if (namespace == VAR_NAMESPACE)
633 ALL_SYMTABS (objfile, s)
635 bv = BLOCKVECTOR (s);
636 block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
637 sym = lookup_block_symbol (block, name, VAR_NAMESPACE);
647 ALL_PSYMTABS (objfile, ps)
649 if (!ps->readin && lookup_partial_symbol (ps, name, 0, VAR_NAMESPACE))
651 s = PSYMTAB_TO_SYMTAB(ps);
652 bv = BLOCKVECTOR (s);
653 block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
654 sym = lookup_block_symbol (block, name, VAR_NAMESPACE);
656 error ("Internal: mangled static symbol `%s' found in %s psymtab but not in symtab", name, ps->filename);
669 /* Look, in partial_symtab PST, for symbol NAME. Check the global
670 symbols if GLOBAL, the static symbols if not */
672 static struct partial_symbol *
673 lookup_partial_symbol (pst, name, global, namespace)
674 struct partial_symtab *pst;
677 enum namespace namespace;
679 struct partial_symbol *start, *psym;
680 struct partial_symbol *top, *bottom, *center;
681 int length = (global ? pst->n_global_syms : pst->n_static_syms);
682 int do_linear_search = 1;
690 pst->objfile->global_psymbols.list + pst->globals_offset :
691 pst->objfile->static_psymbols.list + pst->statics_offset );
693 if (global) /* This means we can use a binary search. */
695 do_linear_search = 0;
697 /* Binary search. This search is guaranteed to end with center
698 pointing at the earliest partial symbol with the correct
699 name. At that point *all* partial symbols with that name
700 will be checked against the correct namespace. */
703 top = start + length - 1;
706 center = bottom + (top - bottom) / 2;
707 assert (center < top);
708 if (!do_linear_search && SYMBOL_LANGUAGE (center) == language_cplus)
710 do_linear_search = 1;
712 if (STRCMP (SYMBOL_NAME (center), name) >= 0)
721 assert (top == bottom);
722 while (STREQ (SYMBOL_NAME (top), name))
724 if (SYMBOL_NAMESPACE (top) == namespace)
732 /* Can't use a binary search or else we found during the binary search that
733 we should also do a linear search. */
735 if (do_linear_search)
737 for (psym = start; psym < start + length; psym++)
739 if (namespace == SYMBOL_NAMESPACE (psym))
741 if (SYMBOL_MATCHES_NAME (psym, name))
752 /* Find the psymtab containing main(). */
753 /* FIXME: What about languages without main() or specially linked
754 executables that have no main() ? */
756 struct partial_symtab *
759 register struct partial_symtab *pst;
760 register struct objfile *objfile;
762 ALL_PSYMTABS (objfile, pst)
764 if (lookup_partial_symbol (pst, "main", 1, VAR_NAMESPACE))
772 /* Search BLOCK for symbol NAME in NAMESPACE.
774 Note that if NAME is the demangled form of a C++ symbol, we will fail
775 to find a match during the binary search of the non-encoded names, but
776 for now we don't worry about the slight inefficiency of looking for
777 a match we'll never find, since it will go pretty quick. Once the
778 binary search terminates, we drop through and do a straight linear
779 search on the symbols. Each symbol which is marked as being a C++
780 symbol (language_cplus set) has both the encoded and non-encoded names
781 tested for a match. */
784 lookup_block_symbol (block, name, namespace)
785 register const struct block *block;
787 const enum namespace namespace;
789 register int bot, top, inc;
790 register struct symbol *sym;
791 register struct symbol *sym_found = NULL;
792 register int do_linear_search = 1;
794 /* If the blocks's symbols were sorted, start with a binary search. */
796 if (BLOCK_SHOULD_SORT (block))
798 /* Reset the linear search flag so if the binary search fails, we
799 won't do the linear search once unless we find some reason to
800 do so, such as finding a C++ symbol during the binary search.
801 Note that for C++ modules, ALL the symbols in a block should
802 end up marked as C++ symbols. */
804 do_linear_search = 0;
805 top = BLOCK_NSYMS (block);
808 /* Advance BOT to not far before the first symbol whose name is NAME. */
812 inc = (top - bot + 1);
813 /* No need to keep binary searching for the last few bits worth. */
818 inc = (inc >> 1) + bot;
819 sym = BLOCK_SYM (block, inc);
820 if (!do_linear_search && SYMBOL_LANGUAGE (sym) == language_cplus)
822 do_linear_search = 1;
824 if (SYMBOL_NAME (sym)[0] < name[0])
828 else if (SYMBOL_NAME (sym)[0] > name[0])
832 else if (STRCMP (SYMBOL_NAME (sym), name) < 0)
842 /* Now scan forward until we run out of symbols, find one whose
843 name is greater than NAME, or find one we want. If there is
844 more than one symbol with the right name and namespace, we
845 return the first one; I believe it is now impossible for us
846 to encounter two symbols with the same name and namespace
847 here, because blocks containing argument symbols are no
850 top = BLOCK_NSYMS (block);
853 sym = BLOCK_SYM (block, bot);
854 inc = SYMBOL_NAME (sym)[0] - name[0];
857 inc = STRCMP (SYMBOL_NAME (sym), name);
859 if (inc == 0 && SYMBOL_NAMESPACE (sym) == namespace)
871 /* Here if block isn't sorted, or we fail to find a match during the
872 binary search above. If during the binary search above, we find a
873 symbol which is a C++ symbol, then we have re-enabled the linear
874 search flag which was reset when starting the binary search.
876 This loop is equivalent to the loop above, but hacked greatly for speed.
878 Note that parameter symbols do not always show up last in the
879 list; this loop makes sure to take anything else other than
880 parameter symbols first; it only uses parameter symbols as a
881 last resort. Note that this only takes up extra computation
884 if (do_linear_search)
886 top = BLOCK_NSYMS (block);
890 sym = BLOCK_SYM (block, bot);
891 if (SYMBOL_NAMESPACE (sym) == namespace &&
892 SYMBOL_MATCHES_NAME (sym, name))
895 if (SYMBOL_CLASS (sym) != LOC_ARG &&
896 SYMBOL_CLASS (sym) != LOC_LOCAL_ARG &&
897 SYMBOL_CLASS (sym) != LOC_REF_ARG &&
898 SYMBOL_CLASS (sym) != LOC_REGPARM &&
899 SYMBOL_CLASS (sym) != LOC_REGPARM_ADDR)
907 return (sym_found); /* Will be NULL if not found. */
911 /* Return the symbol for the function which contains a specified
912 lexical block, described by a struct block BL. */
918 while (BLOCK_FUNCTION (bl) == 0 && BLOCK_SUPERBLOCK (bl) != 0)
919 bl = BLOCK_SUPERBLOCK (bl);
921 return BLOCK_FUNCTION (bl);
924 /* Find the symtab associated with PC. Look through the psymtabs and read in
925 another symtab if necessary. */
929 register CORE_ADDR pc;
931 register struct block *b;
932 struct blockvector *bv;
933 register struct symtab *s = NULL;
934 register struct symtab *best_s = NULL;
935 register struct partial_symtab *ps;
936 register struct objfile *objfile;
940 /* Search all symtabs for one whose file contains our pc */
942 ALL_SYMTABS (objfile, s)
944 bv = BLOCKVECTOR (s);
945 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
946 if (BLOCK_START (b) <= pc
947 && BLOCK_END (b) > pc
949 || BLOCK_END (b) - BLOCK_START (b) < distance))
951 distance = BLOCK_END (b) - BLOCK_START (b);
960 ps = find_pc_psymtab (pc);
964 /* Might want to error() here (in case symtab is corrupt and
965 will cause a core dump), but maybe we can successfully
966 continue, so let's not. */
968 (Internal error: pc 0x%x in read in psymtab, but not in symtab.)\n", pc);
969 s = PSYMTAB_TO_SYMTAB (ps);
974 /* Find the source file and line number for a given PC value.
975 Return a structure containing a symtab pointer, a line number,
976 and a pc range for the entire source line.
977 The value's .pc field is NOT the specified pc.
978 NOTCURRENT nonzero means, if specified pc is on a line boundary,
979 use the line that ends there. Otherwise, in that case, the line
980 that begins there is used. */
982 /* The big complication here is that a line may start in one file, and end just
983 before the start of another file. This usually occurs when you #include
984 code in the middle of a subroutine. To properly find the end of a line's PC
985 range, we must search all symtabs associated with this compilation unit, and
986 find the one whose first PC is closer than that of the next line in this
989 FIXME: We used to complain here about zero length or negative length line
990 tables, but there are two problems with this: (1) some symtabs may not have
991 any line numbers due to gcc -g1 compilation, and (2) this function is called
992 during single stepping, when we don't own the terminal and thus can't
993 produce any output. One solution might be to implement a mechanism whereby
994 complaints can be queued until we regain control of the terminal. -fnf
997 struct symtab_and_line
998 find_pc_line (pc, notcurrent)
1003 register struct linetable *l;
1006 register struct linetable_entry *item;
1007 struct symtab_and_line val;
1008 struct blockvector *bv;
1010 /* Info on best line seen so far, and where it starts, and its file. */
1012 struct linetable_entry *best = NULL;
1013 CORE_ADDR best_end = 0;
1014 struct symtab *best_symtab = 0;
1016 /* Store here the first line number
1017 of a file which contains the line at the smallest pc after PC.
1018 If we don't find a line whose range contains PC,
1019 we will use a line one less than this,
1020 with a range from the start of that file to the first line's pc. */
1021 struct linetable_entry *alt = NULL;
1022 struct symtab *alt_symtab = 0;
1024 /* Info on best line seen in this file. */
1026 struct linetable_entry *prev;
1028 /* If this pc is not from the current frame,
1029 it is the address of the end of a call instruction.
1030 Quite likely that is the start of the following statement.
1031 But what we want is the statement containing the instruction.
1032 Fudge the pc to make sure we get that. */
1034 if (notcurrent) pc -= 1;
1036 s = find_pc_symtab (pc);
1046 bv = BLOCKVECTOR (s);
1048 /* Look at all the symtabs that share this blockvector.
1049 They all have the same apriori range, that we found was right;
1050 but they have different line tables. */
1052 for (; s && BLOCKVECTOR (s) == bv; s = s->next)
1054 /* Find the best line in this symtab. */
1059 if (len <= 0) /* See FIXME above. */
1065 item = l->item; /* Get first line info */
1067 /* Is this file's first line closer than the first lines of other files?
1068 If so, record this file, and its first line, as best alternate. */
1069 if (item->pc > pc && (!alt || item->pc < alt->pc))
1075 for (i = 0; i < len; i++, item++)
1077 /* Return the last line that did not start after PC. */
1084 /* At this point, prev points at the line whose start addr is <= pc, and
1085 item points at the next line. If we ran off the end of the linetable
1086 (pc >= start of the last line), then prev == item. If pc < start of
1087 the first line, prev will not be set. */
1089 /* Is this file's best line closer than the best in the other files?
1090 If so, record this file, and its best line, as best so far. */
1092 if (prev && (!best || prev->pc > best->pc))
1096 /* If another line is in the linetable, and its PC is closer
1097 than the best_end we currently have, take it as best_end. */
1098 if (i < len && (best_end == 0 || best_end > item->pc))
1099 best_end = item->pc;
1106 { /* If we didn't find any line # info, just
1115 val.symtab = alt_symtab;
1116 val.line = alt->line - 1;
1117 val.pc = BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK));
1123 val.symtab = best_symtab;
1124 val.line = best->line;
1126 if (best_end && (!alt || best_end < alt->pc))
1131 val.end = BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK));
1136 /* Find the PC value for a given source file and line number.
1137 Returns zero for invalid line number.
1138 The source file is specified with a struct symtab. */
1141 find_line_pc (symtab, line)
1142 struct symtab *symtab;
1145 register struct linetable *l;
1151 l = LINETABLE (symtab);
1152 ind = find_line_common(l, line, &dummy);
1153 return (ind >= 0) ? l->item[ind].pc : 0;
1156 /* Find the range of pc values in a line.
1157 Store the starting pc of the line into *STARTPTR
1158 and the ending pc (start of next line) into *ENDPTR.
1159 Returns 1 to indicate success.
1160 Returns 0 if could not find the specified line. */
1163 find_line_pc_range (symtab, thisline, startptr, endptr)
1164 struct symtab *symtab;
1166 CORE_ADDR *startptr, *endptr;
1168 register struct linetable *l;
1170 int exact_match; /* did we get an exact linenumber match */
1175 l = LINETABLE (symtab);
1176 ind = find_line_common (l, thisline, &exact_match);
1179 *startptr = l->item[ind].pc;
1180 /* If we have not seen an entry for the specified line,
1181 assume that means the specified line has zero bytes. */
1182 if (!exact_match || ind == l->nitems-1)
1183 *endptr = *startptr;
1185 /* Perhaps the following entry is for the following line.
1186 It's worth a try. */
1187 if (ind+1 < l->nitems
1188 && l->item[ind+1].line == thisline + 1)
1189 *endptr = l->item[ind+1].pc;
1191 *endptr = find_line_pc (symtab, thisline+1);
1198 /* Given a line table and a line number, return the index into the line
1199 table for the pc of the nearest line whose number is >= the specified one.
1200 Return -1 if none is found. The value is >= 0 if it is an index.
1202 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
1205 find_line_common (l, lineno, exact_match)
1206 register struct linetable *l;
1207 register int lineno;
1213 /* BEST is the smallest linenumber > LINENO so far seen,
1214 or 0 if none has been seen so far.
1215 BEST_INDEX identifies the item for it. */
1217 int best_index = -1;
1226 for (i = 0; i < len; i++)
1228 register struct linetable_entry *item = &(l->item[i]);
1230 if (item->line == lineno)
1236 if (item->line > lineno && (best == 0 || item->line < best))
1243 /* If we got here, we didn't get an exact match. */
1250 find_pc_line_pc_range (pc, startptr, endptr)
1252 CORE_ADDR *startptr, *endptr;
1254 struct symtab_and_line sal;
1255 sal = find_pc_line (pc, 0);
1258 return sal.symtab != 0;
1261 /* If P is of the form "operator[ \t]+..." where `...' is
1262 some legitimate operator text, return a pointer to the
1263 beginning of the substring of the operator text.
1264 Otherwise, return "". */
1266 operator_chars (p, end)
1271 if (strncmp (p, "operator", 8))
1275 /* Don't get faked out by `operator' being part of a longer
1277 if (isalpha(*p) || *p == '_' || *p == '$' || *p == '\0')
1280 /* Allow some whitespace between `operator' and the operator symbol. */
1281 while (*p == ' ' || *p == '\t')
1284 /* Recognize 'operator TYPENAME'. */
1286 if (isalpha(*p) || *p == '_' || *p == '$')
1288 register char *q = p+1;
1289 while (isalnum(*q) || *q == '_' || *q == '$')
1314 if (p[1] == '=' || p[1] == p[0])
1325 error ("`operator ()' must be specified without whitespace in `()'");
1330 error ("`operator ?:' must be specified without whitespace in `?:'");
1335 error ("`operator []' must be specified without whitespace in `[]'");
1339 error ("`operator %s' not supported", p);
1346 /* Recursive helper function for decode_line_1.
1347 * Look for methods named NAME in type T.
1348 * Return number of matches.
1349 * Put matches in SYM_ARR (which better be big enough!).
1350 * These allocations seem to define "big enough":
1351 * sym_arr = (struct symbol **) alloca(TYPE_NFN_FIELDS_TOTAL (t) * sizeof(struct symbol*));
1352 * Note that this function is g++ specific.
1356 find_methods (t, name, sym_arr)
1359 struct symbol **sym_arr;
1363 struct symbol *sym_class;
1364 char *class_name = type_name_no_tag (t);
1365 /* Ignore this class if it doesn't have a name.
1366 This prevents core dumps, but is just a workaround
1367 because we might not find the function in
1368 certain cases, such as
1369 struct D {virtual int f();}
1370 struct C : D {virtual int g();}
1371 (in this case g++ 1.35.1- does not put out a name
1372 for D as such, it defines type 19 (for example) in
1373 the same stab as C, and then does a
1374 .stabs "D:T19" and a .stabs "D:t19".
1376 "break C::f" should not be looking for field f in
1378 but just for the field f in the baseclasses of C
1379 (no matter what their names).
1381 However, I don't know how to replace the code below
1382 that depends on knowing the name of D. */
1384 && (sym_class = lookup_symbol (class_name,
1385 (struct block *)NULL,
1388 (struct symtab **)NULL)))
1391 t = SYMBOL_TYPE (sym_class);
1392 for (method_counter = TYPE_NFN_FIELDS (t) - 1;
1393 method_counter >= 0;
1397 struct fn_field *f = TYPE_FN_FIELDLIST1 (t, method_counter);
1399 char *method_name = TYPE_FN_FIELDLIST_NAME (t, method_counter);
1400 if (STREQ (name, method_name))
1401 /* Find all the fields with that name. */
1402 for (field_counter = TYPE_FN_FIELDLIST_LENGTH (t, method_counter) - 1;
1407 if (TYPE_FN_FIELD_STUB (f, field_counter))
1408 check_stub_method (t, method_counter, field_counter);
1409 phys_name = TYPE_FN_FIELD_PHYSNAME (f, field_counter);
1410 /* Destructor is handled by caller, dont add it to the list */
1411 if (DESTRUCTOR_PREFIX_P (phys_name))
1413 sym_arr[i1] = lookup_symbol (phys_name,
1414 SYMBOL_BLOCK_VALUE (sym_class),
1417 (struct symtab **) NULL);
1418 if (sym_arr[i1]) i1++;
1421 fputs_filtered("(Cannot find method ", stdout);
1422 fprintf_symbol_filtered (stdout, phys_name,
1423 language_cplus, DMGL_PARAMS);
1424 fputs_filtered(" - possibly inlined.)\n", stdout);
1429 /* Only search baseclasses if there is no match yet,
1430 * since names in derived classes override those in baseclasses.
1434 for (ibase = 0; ibase < TYPE_N_BASECLASSES (t); ibase++)
1435 i1 += find_methods(TYPE_BASECLASS(t, ibase), name,
1440 /* Helper function for decode_line_1.
1441 Build a canonical line spec in CANONICAL if it is non-NULL and if
1442 the SAL has a symtab.
1443 If SYMNAME is non-NULL the canonical line spec is `filename:symname'.
1444 If SYMNAME is NULL the line number from SAL is used and the canonical
1445 line spec is `filename:linenum'. */
1448 build_canonical_line_spec (sal, symname, canonical)
1449 struct symtab_and_line *sal;
1453 char **canonical_arr;
1454 char *canonical_name;
1456 struct symtab *s = sal->symtab;
1458 if (s == (struct symtab *)NULL
1459 || s->filename == (char *)NULL
1460 || canonical == (char ***)NULL)
1463 canonical_arr = (char **) xmalloc (sizeof (char *));
1464 *canonical = canonical_arr;
1466 filename = s->filename;
1467 if (symname != NULL)
1469 canonical_name = xmalloc (strlen (filename) + strlen (symname) + 2);
1470 sprintf (canonical_name, "%s:%s", filename, symname);
1474 canonical_name = xmalloc (strlen (filename) + 30);
1475 sprintf (canonical_name, "%s:%d", filename, sal->line);
1477 canonical_arr[0] = canonical_name;
1480 /* Parse a string that specifies a line number.
1481 Pass the address of a char * variable; that variable will be
1482 advanced over the characters actually parsed.
1486 LINENUM -- that line number in current file. PC returned is 0.
1487 FILE:LINENUM -- that line in that file. PC returned is 0.
1488 FUNCTION -- line number of openbrace of that function.
1489 PC returned is the start of the function.
1490 VARIABLE -- line number of definition of that variable.
1492 FILE:FUNCTION -- likewise, but prefer functions in that file.
1493 *EXPR -- line in which address EXPR appears.
1495 FUNCTION may be an undebuggable function found in minimal symbol table.
1497 If the argument FUNFIRSTLINE is nonzero, we want the first line
1498 of real code inside a function when a function is specified.
1500 DEFAULT_SYMTAB specifies the file to use if none is specified.
1501 It defaults to current_source_symtab.
1502 DEFAULT_LINE specifies the line number to use for relative
1503 line numbers (that start with signs). Defaults to current_source_line.
1504 If CANONICAL is non-NULL, store an array of strings containing the canonical
1505 line specs there if necessary. Currently overloaded member functions and
1506 line numbers or static functions without a filename yield a canonical
1507 line spec. The array and the line spec strings are allocated on the heap,
1508 it is the callers responsibility to free them.
1510 Note that it is possible to return zero for the symtab
1511 if no file is validly specified. Callers must check that.
1512 Also, the line number returned may be invalid. */
1514 struct symtabs_and_lines
1515 decode_line_1 (argptr, funfirstline, default_symtab, default_line, canonical)
1518 struct symtab *default_symtab;
1522 struct symtabs_and_lines values;
1523 #ifdef HPPA_COMPILER_BUG
1524 /* FIXME: The native HP 9000/700 compiler has a bug which appears
1525 when optimizing this file with target i960-vxworks. I haven't
1526 been able to construct a simple test case. The problem is that
1527 in the second call to SKIP_PROLOGUE below, the compiler somehow
1528 does not realize that the statement val = find_pc_line (...) will
1529 change the values of the fields of val. It extracts the elements
1530 into registers at the top of the block, and does not update the
1531 registers after the call to find_pc_line. You can check this by
1532 inserting a printf at the end of find_pc_line to show what values
1533 it is returning for val.pc and val.end and another printf after
1534 the call to see what values the function actually got (remember,
1535 this is compiling with cc -O, with this patch removed). You can
1536 also examine the assembly listing: search for the second call to
1537 skip_prologue; the LDO statement before the next call to
1538 find_pc_line loads the address of the structure which
1539 find_pc_line will return; if there is a LDW just before the LDO,
1540 which fetches an element of the structure, then the compiler
1543 Setting val to volatile avoids the problem. We must undef
1544 volatile, because the HPPA native compiler does not define
1545 __STDC__, although it does understand volatile, and so volatile
1546 will have been defined away in defs.h. */
1548 volatile struct symtab_and_line val;
1549 #define volatile /*nothing*/
1551 struct symtab_and_line val;
1553 register char *p, *p1;
1555 register struct symtab *s;
1557 register struct symbol *sym;
1558 /* The symtab that SYM was found in. */
1559 struct symtab *sym_symtab;
1561 register CORE_ADDR pc;
1562 register struct minimal_symbol *msymbol;
1564 struct symbol *sym_class;
1567 struct symbol **sym_arr;
1569 char *saved_arg = *argptr;
1570 extern char *gdb_completer_quote_characters;
1572 /* Defaults have defaults. */
1574 if (default_symtab == 0)
1576 default_symtab = current_source_symtab;
1577 default_line = current_source_line;
1580 /* See if arg is *PC */
1582 if (**argptr == '*')
1584 if (**argptr == '*')
1588 pc = parse_and_eval_address_1 (argptr);
1589 values.sals = (struct symtab_and_line *)
1590 xmalloc (sizeof (struct symtab_and_line));
1592 values.sals[0] = find_pc_line (pc, 0);
1593 values.sals[0].pc = pc;
1594 build_canonical_line_spec (values.sals, NULL, canonical);
1598 /* Maybe arg is FILE : LINENUM or FILE : FUNCTION */
1601 is_quoted = (strchr (gdb_completer_quote_characters, **argptr) != NULL);
1603 for (p = *argptr; *p; p++)
1605 if (p[0] == ':' || p[0] == ' ' || p[0] == '\t')
1608 while (p[0] == ' ' || p[0] == '\t') p++;
1610 if ((p[0] == ':') && !is_quoted)
1616 /* Extract the class name. */
1618 while (p != *argptr && p[-1] == ' ') --p;
1619 copy = (char *) alloca (p - *argptr + 1);
1620 memcpy (copy, *argptr, p - *argptr);
1621 copy[p - *argptr] = 0;
1623 /* Discard the class name from the arg. */
1625 while (*p == ' ' || *p == '\t') p++;
1628 sym_class = lookup_symbol (copy, 0, STRUCT_NAMESPACE, 0,
1629 (struct symtab **)NULL);
1632 ( TYPE_CODE (SYMBOL_TYPE (sym_class)) == TYPE_CODE_STRUCT
1633 || TYPE_CODE (SYMBOL_TYPE (sym_class)) == TYPE_CODE_UNION))
1635 /* Arg token is not digits => try it as a function name
1636 Find the next token (everything up to end or next whitespace). */
1638 while (*p && *p != ' ' && *p != '\t' && *p != ',' && *p !=':') p++;
1639 q = operator_chars (*argptr, &q1);
1644 char *tmp = alloca (q1 - q + 1);
1645 memcpy (tmp, q, q1 - q);
1647 opname = cplus_mangle_opname (tmp, DMGL_ANSI);
1650 warning ("no mangling for \"%s\"", tmp);
1651 cplusplus_hint (saved_arg);
1652 return_to_top_level (RETURN_ERROR);
1654 copy = (char*) alloca (3 + strlen(opname));
1655 sprintf (copy, "__%s", opname);
1660 copy = (char *) alloca (p - *argptr + 1 + (q1 - q));
1661 memcpy (copy, *argptr, p - *argptr);
1662 copy[p - *argptr] = '\0';
1665 /* no line number may be specified */
1666 while (*p == ' ' || *p == '\t') p++;
1670 i1 = 0; /* counter for the symbol array */
1671 t = SYMBOL_TYPE (sym_class);
1672 sym_arr = (struct symbol **) alloca(TYPE_NFN_FIELDS_TOTAL (t) * sizeof(struct symbol*));
1674 if (destructor_name_p (copy, t))
1676 /* destructors are a special case. */
1677 struct fn_field *f = TYPE_FN_FIELDLIST1 (t, 0);
1678 int len = TYPE_FN_FIELDLIST_LENGTH (t, 0) - 1;
1679 /* gcc 1.x puts destructor in last field,
1680 gcc 2.x puts destructor in first field. */
1681 char *phys_name = TYPE_FN_FIELD_PHYSNAME (f, len);
1682 if (!DESTRUCTOR_PREFIX_P (phys_name))
1684 phys_name = TYPE_FN_FIELD_PHYSNAME (f, 0);
1685 if (!DESTRUCTOR_PREFIX_P (phys_name))
1689 lookup_symbol (phys_name, SYMBOL_BLOCK_VALUE (sym_class),
1690 VAR_NAMESPACE, 0, (struct symtab **)NULL);
1691 if (sym_arr[i1]) i1++;
1694 i1 = find_methods (t, copy, sym_arr);
1697 /* There is exactly one field with that name. */
1700 if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
1702 /* Arg is the name of a function */
1703 pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) + FUNCTION_START_OFFSET;
1706 values.sals = (struct symtab_and_line *)xmalloc (sizeof (struct symtab_and_line));
1708 values.sals[0] = find_pc_line (pc, 0);
1709 values.sals[0].pc = (values.sals[0].end && values.sals[0].pc != pc) ? values.sals[0].end : pc;
1719 /* There is more than one field with that name
1720 (overloaded). Ask the user which one to use. */
1721 return decode_line_2 (sym_arr, i1, funfirstline, canonical);
1727 if (OPNAME_PREFIX_P (copy))
1729 tmp = (char *)alloca (strlen (copy+3) + 9);
1730 strcpy (tmp, "operator ");
1731 strcat (tmp, copy+3);
1736 warning ("the class `%s' does not have destructor defined",
1737 SYMBOL_SOURCE_NAME(sym_class));
1739 warning ("the class %s does not have any method named %s",
1740 SYMBOL_SOURCE_NAME(sym_class), tmp);
1741 cplusplus_hint (saved_arg);
1742 return_to_top_level (RETURN_ERROR);
1747 /* The quotes are important if copy is empty. */
1748 warning ("can't find class, struct, or union named \"%s\"",
1750 cplusplus_hint (saved_arg);
1751 return_to_top_level (RETURN_ERROR);
1757 /* Extract the file name. */
1759 while (p != *argptr && p[-1] == ' ') --p;
1760 copy = (char *) alloca (p - *argptr + 1);
1761 memcpy (copy, *argptr, p - *argptr);
1762 copy[p - *argptr] = 0;
1764 /* Find that file's data. */
1765 s = lookup_symtab (copy);
1768 if (!have_full_symbols () && !have_partial_symbols ())
1769 error (no_symtab_msg);
1770 error ("No source file named %s.", copy);
1773 /* Discard the file name from the arg. */
1775 while (*p == ' ' || *p == '\t') p++;
1779 /* S is specified file's symtab, or 0 if no file specified.
1780 arg no longer contains the file name. */
1782 /* Check whether arg is all digits (and sign) */
1785 if (*p == '-' || *p == '+') p++;
1786 while (*p >= '0' && *p <= '9')
1789 if (p != *argptr && (*p == 0 || *p == ' ' || *p == '\t' || *p == ','))
1791 /* We found a token consisting of all digits -- at least one digit. */
1792 enum sign {none, plus, minus} sign = none;
1794 /* We might need a canonical line spec if no file was specified. */
1795 int need_canonical = (s == 0) ? 1 : 0;
1797 /* This is where we need to make sure that we have good defaults.
1798 We must guarantee that this section of code is never executed
1799 when we are called with just a function name, since
1800 select_source_symtab calls us with such an argument */
1802 if (s == 0 && default_symtab == 0)
1804 select_source_symtab (0);
1805 default_symtab = current_source_symtab;
1806 default_line = current_source_line;
1809 if (**argptr == '+')
1810 sign = plus, (*argptr)++;
1811 else if (**argptr == '-')
1812 sign = minus, (*argptr)++;
1813 val.line = atoi (*argptr);
1820 val.line = default_line + val.line;
1826 val.line = default_line - val.line;
1831 break; /* No need to adjust val.line. */
1834 while (*p == ' ' || *p == '\t') p++;
1840 values.sals = (struct symtab_and_line *)xmalloc (sizeof (struct symtab_and_line));
1841 values.sals[0] = val;
1844 build_canonical_line_spec (values.sals, NULL, canonical);
1848 /* Arg token is not digits => try it as a variable name
1849 Find the next token (everything up to end or next whitespace). */
1851 p = skip_quoted (*argptr);
1852 copy = (char *) alloca (p - *argptr + 1);
1853 memcpy (copy, *argptr, p - *argptr);
1854 copy[p - *argptr] = '\0';
1855 if ((copy[0] == copy [p - *argptr - 1])
1856 && strchr (gdb_completer_quote_characters, copy[0]) != NULL)
1859 copy [p - *argptr - 1] = '\0';
1862 while (*p == ' ' || *p == '\t') p++;
1865 /* Look up that token as a variable.
1866 If file specified, use that file's per-file block to start with. */
1868 sym = lookup_symbol (copy,
1869 (s ? BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK)
1870 : get_selected_block ()),
1871 VAR_NAMESPACE, 0, &sym_symtab);
1875 if (SYMBOL_CLASS (sym) == LOC_BLOCK)
1877 /* Arg is the name of a function */
1878 pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) + FUNCTION_START_OFFSET;
1881 val = find_pc_line (pc, 0);
1882 #ifdef PROLOGUE_FIRSTLINE_OVERLAP
1883 /* Convex: no need to suppress code on first line, if any */
1886 /* Check if SKIP_PROLOGUE left us in mid-line, and the next
1887 line is still part of the same function. */
1889 && BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) <= val.end
1890 && val.end < BLOCK_END (SYMBOL_BLOCK_VALUE (sym)))
1892 /* First pc of next line */
1894 /* Recalculate the line number (might not be N+1). */
1895 val = find_pc_line (pc, 0);
1899 values.sals = (struct symtab_and_line *)xmalloc (sizeof (struct symtab_and_line));
1900 values.sals[0] = val;
1903 /* I think this is always the same as the line that
1904 we calculate above, but the general principle is
1905 "trust the symbols more than stuff like
1907 if (SYMBOL_LINE (sym) != 0)
1908 values.sals[0].line = SYMBOL_LINE (sym);
1910 /* We might need a canonical line spec if it is a static function. */
1913 struct blockvector *bv = BLOCKVECTOR (sym_symtab);
1914 struct block *b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
1915 if (lookup_block_symbol (b, copy, VAR_NAMESPACE) != NULL)
1916 build_canonical_line_spec (values.sals, copy, canonical);
1920 else if (SYMBOL_LINE (sym) != 0)
1922 /* We know its line number. */
1923 values.sals = (struct symtab_and_line *)
1924 xmalloc (sizeof (struct symtab_and_line));
1926 memset (&values.sals[0], 0, sizeof (values.sals[0]));
1927 values.sals[0].symtab = sym_symtab;
1928 values.sals[0].line = SYMBOL_LINE (sym);
1932 /* This can happen if it is compiled with a compiler which doesn't
1933 put out line numbers for variables. */
1934 /* FIXME: Shouldn't we just set .line and .symtab to zero and
1935 return? For example, "info line foo" could print the address. */
1936 error ("Line number not known for symbol \"%s\"", copy);
1939 msymbol = lookup_minimal_symbol (copy, (struct objfile *) NULL);
1940 if (msymbol != NULL)
1944 val.pc = SYMBOL_VALUE_ADDRESS (msymbol) + FUNCTION_START_OFFSET;
1946 SKIP_PROLOGUE (val.pc);
1947 values.sals = (struct symtab_and_line *)xmalloc (sizeof (struct symtab_and_line));
1948 values.sals[0] = val;
1953 if (!have_full_symbols () &&
1954 !have_partial_symbols () && !have_minimal_symbols ())
1955 error (no_symtab_msg);
1957 error ("Function \"%s\" not defined.", copy);
1958 return values; /* for lint */
1961 struct symtabs_and_lines
1962 decode_line_spec (string, funfirstline)
1966 struct symtabs_and_lines sals;
1968 error ("Empty line specification.");
1969 sals = decode_line_1 (&string, funfirstline,
1970 current_source_symtab, current_source_line,
1973 error ("Junk at end of line specification: %s", string);
1977 /* Given a list of NELTS symbols in SYM_ARR, return a list of lines to
1978 operate on (ask user if necessary).
1979 If CANONICAL is non-NULL return a corresponding array of mangled names
1980 as canonical line specs there. */
1982 static struct symtabs_and_lines
1983 decode_line_2 (sym_arr, nelts, funfirstline, canonical)
1984 struct symbol *sym_arr[];
1989 struct symtabs_and_lines values, return_values;
1990 register CORE_ADDR pc;
1995 struct cleanup *old_chain;
1996 char **canonical_arr = (char **)NULL;
1998 values.sals = (struct symtab_and_line *) alloca (nelts * sizeof(struct symtab_and_line));
1999 return_values.sals = (struct symtab_and_line *) xmalloc (nelts * sizeof(struct symtab_and_line));
2000 old_chain = make_cleanup (free, return_values.sals);
2004 canonical_arr = (char **) xmalloc (nelts * sizeof (char *));
2005 make_cleanup (free, canonical_arr);
2006 memset (canonical_arr, 0, nelts * sizeof (char *));
2007 *canonical = canonical_arr;
2011 printf("[0] cancel\n[1] all\n");
2014 if (sym_arr[i] && SYMBOL_CLASS (sym_arr[i]) == LOC_BLOCK)
2016 /* Arg is the name of a function */
2017 pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym_arr[i]))
2018 + FUNCTION_START_OFFSET;
2021 values.sals[i] = find_pc_line (pc, 0);
2022 values.sals[i].pc = (values.sals[i].end && values.sals[i].pc != pc) ?
2023 values.sals[i].end : pc;
2024 printf("[%d] %s at %s:%d\n", (i+2), SYMBOL_SOURCE_NAME (sym_arr[i]),
2025 values.sals[i].symtab->filename, values.sals[i].line);
2027 else printf ("?HERE\n");
2031 if ((prompt = getenv ("PS2")) == NULL)
2035 printf("%s ",prompt);
2038 args = command_line_input ((char *) NULL, 0);
2040 if (args == 0 || *args == 0)
2041 error_no_arg ("one or more choice numbers");
2049 while (*arg1 >= '0' && *arg1 <= '9') arg1++;
2050 if (*arg1 && *arg1 != ' ' && *arg1 != '\t')
2051 error ("Arguments must be choice numbers.");
2056 error ("cancelled");
2061 for (i = 0; i < nelts; i++)
2063 if (canonical_arr[i] == NULL)
2065 symname = SYMBOL_NAME (sym_arr[i]);
2066 canonical_arr[i] = savestring (symname, strlen (symname));
2070 memcpy (return_values.sals, values.sals,
2071 (nelts * sizeof(struct symtab_and_line)));
2072 return_values.nelts = nelts;
2073 discard_cleanups (old_chain);
2074 return return_values;
2077 if (num > nelts + 2)
2079 printf ("No choice number %d.\n", num);
2084 if (values.sals[num].pc)
2088 symname = SYMBOL_NAME (sym_arr[num]);
2089 make_cleanup (free, symname);
2090 canonical_arr[i] = savestring (symname, strlen (symname));
2092 return_values.sals[i++] = values.sals[num];
2093 values.sals[num].pc = 0;
2097 printf ("duplicate request for %d ignored.\n", num);
2102 while (*args == ' ' || *args == '\t') args++;
2104 return_values.nelts = i;
2105 discard_cleanups (old_chain);
2106 return return_values;
2110 /* Slave routine for sources_info. Force line breaks at ,'s.
2111 NAME is the name to print and *FIRST is nonzero if this is the first
2112 name printed. Set *FIRST to zero. */
2114 output_source_filename (name, first)
2118 /* Table of files printed so far. Since a single source file can
2119 result in several partial symbol tables, we need to avoid printing
2120 it more than once. Note: if some of the psymtabs are read in and
2121 some are not, it gets printed both under "Source files for which
2122 symbols have been read" and "Source files for which symbols will
2123 be read in on demand". I consider this a reasonable way to deal
2124 with the situation. I'm not sure whether this can also happen for
2125 symtabs; it doesn't hurt to check. */
2126 static char **tab = NULL;
2127 /* Allocated size of tab in elements.
2128 Start with one 256-byte block (when using GNU malloc.c).
2129 24 is the malloc overhead when range checking is in effect. */
2130 static int tab_alloc_size = (256 - 24) / sizeof (char *);
2131 /* Current size of tab in elements. */
2132 static int tab_cur_size;
2139 tab = (char **) xmalloc (tab_alloc_size * sizeof (*tab));
2143 /* Is NAME in tab? */
2144 for (p = tab; p < tab + tab_cur_size; p++)
2145 if (STREQ (*p, name))
2146 /* Yes; don't print it again. */
2148 /* No; add it to tab. */
2149 if (tab_cur_size == tab_alloc_size)
2151 tab_alloc_size *= 2;
2152 tab = (char **) xrealloc ((char *) tab, tab_alloc_size * sizeof (*tab));
2154 tab[tab_cur_size++] = name;
2162 printf_filtered (", ");
2166 fputs_filtered (name, stdout);
2170 sources_info (ignore, from_tty)
2174 register struct symtab *s;
2175 register struct partial_symtab *ps;
2176 register struct objfile *objfile;
2179 if (!have_full_symbols () && !have_partial_symbols ())
2181 error (no_symtab_msg);
2184 printf_filtered ("Source files for which symbols have been read in:\n\n");
2187 ALL_SYMTABS (objfile, s)
2189 output_source_filename (s -> filename, &first);
2191 printf_filtered ("\n\n");
2193 printf_filtered ("Source files for which symbols will be read in on demand:\n\n");
2196 ALL_PSYMTABS (objfile, ps)
2200 output_source_filename (ps -> filename, &first);
2203 printf_filtered ("\n");
2206 /* List all symbols (if REGEXP is NULL) or all symbols matching REGEXP.
2207 If CLASS is zero, list all symbols except functions, type names, and
2209 If CLASS is 1, list only functions.
2210 If CLASS is 2, list only type names.
2211 If CLASS is 3, list only method names.
2213 BPT is non-zero if we should set a breakpoint at the functions
2217 list_symbols (regexp, class, bpt)
2222 register struct symtab *s;
2223 register struct partial_symtab *ps;
2224 register struct blockvector *bv;
2225 struct blockvector *prev_bv = 0;
2226 register struct block *b;
2228 register struct symbol *sym;
2229 struct partial_symbol *psym;
2230 struct objfile *objfile;
2231 struct minimal_symbol *msymbol;
2233 static char *classnames[]
2234 = {"variable", "function", "type", "method"};
2235 int found_in_file = 0;
2237 static enum minimal_symbol_type types[]
2238 = {mst_data, mst_text, mst_abs, mst_unknown};
2239 static enum minimal_symbol_type types2[]
2240 = {mst_bss, mst_text, mst_abs, mst_unknown};
2241 enum minimal_symbol_type ourtype = types[class];
2242 enum minimal_symbol_type ourtype2 = types2[class];
2246 /* Make sure spacing is right for C++ operators.
2247 This is just a courtesy to make the matching less sensitive
2248 to how many spaces the user leaves between 'operator'
2249 and <TYPENAME> or <OPERATOR>. */
2251 char *opname = operator_chars (regexp, &opend);
2254 int fix = -1; /* -1 means ok; otherwise number of spaces needed. */
2255 if (isalpha(*opname) || *opname == '_' || *opname == '$')
2257 /* There should 1 space between 'operator' and 'TYPENAME'. */
2258 if (opname[-1] != ' ' || opname[-2] == ' ')
2263 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
2264 if (opname[-1] == ' ')
2267 /* If wrong number of spaces, fix it. */
2270 char *tmp = (char*) alloca(opend-opname+10);
2271 sprintf(tmp, "operator%.*s%s", fix, " ", opname);
2276 if (0 != (val = re_comp (regexp)))
2277 error ("Invalid regexp (%s): %s", val, regexp);
2280 /* Search through the partial symtabs *first* for all symbols
2281 matching the regexp. That way we don't have to reproduce all of
2282 the machinery below. */
2284 ALL_PSYMTABS (objfile, ps)
2286 struct partial_symbol *bound, *gbound, *sbound;
2289 if (ps->readin) continue;
2291 gbound = objfile->global_psymbols.list + ps->globals_offset + ps->n_global_syms;
2292 sbound = objfile->static_psymbols.list + ps->statics_offset + ps->n_static_syms;
2295 /* Go through all of the symbols stored in a partial
2296 symtab in one loop. */
2297 psym = objfile->global_psymbols.list + ps->globals_offset;
2302 if (bound == gbound && ps->n_static_syms != 0)
2304 psym = objfile->static_psymbols.list + ps->statics_offset;
2315 /* If it would match (logic taken from loop below)
2316 load the file and go on to the next one */
2317 if ((regexp == NULL || SYMBOL_MATCHES_REGEXP (psym))
2318 && ((class == 0 && SYMBOL_CLASS (psym) != LOC_TYPEDEF
2319 && SYMBOL_CLASS (psym) != LOC_BLOCK)
2320 || (class == 1 && SYMBOL_CLASS (psym) == LOC_BLOCK)
2321 || (class == 2 && SYMBOL_CLASS (psym) == LOC_TYPEDEF)
2322 || (class == 3 && SYMBOL_CLASS (psym) == LOC_BLOCK)))
2324 PSYMTAB_TO_SYMTAB(ps);
2332 /* Here, we search through the minimal symbol tables for functions that
2333 match, and call find_pc_symtab on them to force their symbols to
2334 be read. The symbol will then be found during the scan of symtabs
2335 below. If find_pc_symtab fails, set found_misc so that we will
2336 rescan to print any matching symbols without debug info. */
2340 ALL_MSYMBOLS (objfile, msymbol)
2342 if (MSYMBOL_TYPE (msymbol) == ourtype ||
2343 MSYMBOL_TYPE (msymbol) == ourtype2)
2345 if (regexp == NULL || SYMBOL_MATCHES_REGEXP (msymbol))
2347 if (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol)))
2356 /* Printout here so as to get after the "Reading in symbols"
2357 messages which will be generated above. */
2359 printf_filtered (regexp
2360 ? "All %ss matching regular expression \"%s\":\n"
2361 : "All defined %ss:\n",
2365 ALL_SYMTABS (objfile, s)
2368 bv = BLOCKVECTOR (s);
2369 /* Often many files share a blockvector.
2370 Scan each blockvector only once so that
2371 we don't get every symbol many times.
2372 It happens that the first symtab in the list
2373 for any given blockvector is the main file. */
2375 for (i = GLOBAL_BLOCK; i <= STATIC_BLOCK; i++)
2377 b = BLOCKVECTOR_BLOCK (bv, i);
2378 /* Skip the sort if this block is always sorted. */
2379 if (!BLOCK_SHOULD_SORT (b))
2380 sort_block_syms (b);
2381 for (j = 0; j < BLOCK_NSYMS (b); j++)
2384 sym = BLOCK_SYM (b, j);
2385 if ((regexp == NULL || SYMBOL_MATCHES_REGEXP (sym))
2386 && ((class == 0 && SYMBOL_CLASS (sym) != LOC_TYPEDEF
2387 && SYMBOL_CLASS (sym) != LOC_BLOCK
2388 && SYMBOL_CLASS (sym) != LOC_CONST)
2389 || (class == 1 && SYMBOL_CLASS (sym) == LOC_BLOCK)
2390 || (class == 2 && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
2391 || (class == 3 && SYMBOL_CLASS (sym) == LOC_BLOCK)))
2395 /* Set a breakpoint here, if it's a function */
2398 /* There may be more than one function with the
2399 same name but in different files. In order to
2400 set breakpoints on all of them, we must give
2401 both the file name and the function name to
2404 (char *) alloca (strlen (s->filename)
2405 + strlen (SYMBOL_NAME(sym))
2407 strcpy (string, s->filename);
2408 strcat (string, ":");
2409 strcat (string, SYMBOL_NAME(sym));
2410 break_command (string, 0);
2413 else if (!found_in_file)
2415 fputs_filtered ("\nFile ", stdout);
2416 fputs_filtered (s->filename, stdout);
2417 fputs_filtered (":\n", stdout);
2421 if (class != 2 && i == STATIC_BLOCK)
2422 printf_filtered ("static ");
2424 /* Typedef that is not a C++ class */
2426 && SYMBOL_NAMESPACE (sym) != STRUCT_NAMESPACE)
2427 c_typedef_print (SYMBOL_TYPE(sym), sym, stdout);
2428 /* variable, func, or typedef-that-is-c++-class */
2429 else if (class < 2 ||
2431 SYMBOL_NAMESPACE(sym) == STRUCT_NAMESPACE))
2433 type_print (SYMBOL_TYPE (sym),
2434 (SYMBOL_CLASS (sym) == LOC_TYPEDEF
2435 ? "" : SYMBOL_SOURCE_NAME (sym)),
2438 printf_filtered (";\n");
2442 # if 0 /* FIXME, why is this zapped out? */
2444 c_type_print_base (TYPE_FN_FIELD_TYPE(t, i),
2446 c_type_print_varspec_prefix (TYPE_FN_FIELD_TYPE(t, i),
2448 sprintf (buf, " %s::", type_name_no_tag (t));
2449 cp_type_print_method_args (TYPE_FN_FIELD_ARGS (t, i),
2459 /* If there are no eyes, avoid all contact. I mean, if there are
2460 no debug symbols, then print directly from the msymbol_vector. */
2462 if (found_misc || class != 1)
2465 ALL_MSYMBOLS (objfile, msymbol)
2467 if (MSYMBOL_TYPE (msymbol) == ourtype ||
2468 MSYMBOL_TYPE (msymbol) == ourtype2)
2470 if (regexp == NULL || SYMBOL_MATCHES_REGEXP (msymbol))
2472 /* Functions: Look up by address. */
2474 (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol))))
2476 /* Variables/Absolutes: Look up by name */
2477 if (lookup_symbol (SYMBOL_NAME (msymbol),
2478 (struct block *) NULL, VAR_NAMESPACE,
2479 0, (struct symtab **) NULL) == NULL)
2483 printf_filtered ("\nNon-debugging symbols:\n");
2486 printf_filtered (" %08x %s\n",
2487 SYMBOL_VALUE_ADDRESS (msymbol),
2488 SYMBOL_SOURCE_NAME (msymbol));
2498 variables_info (regexp, from_tty)
2502 list_symbols (regexp, 0, 0);
2506 functions_info (regexp, from_tty)
2510 list_symbols (regexp, 1, 0);
2514 types_info (regexp, from_tty)
2518 list_symbols (regexp, 2, 0);
2522 /* Tiemann says: "info methods was never implemented." */
2524 methods_info (regexp)
2527 list_symbols (regexp, 3, 0);
2531 /* Breakpoint all functions matching regular expression. */
2533 rbreak_command (regexp, from_tty)
2537 list_symbols (regexp, 1, 1);
2541 /* Return Nonzero if block a is lexically nested within block b,
2542 or if a and b have the same pc range.
2543 Return zero otherwise. */
2546 struct block *a, *b;
2550 return BLOCK_START (a) >= BLOCK_START (b)
2551 && BLOCK_END (a) <= BLOCK_END (b);
2555 /* Helper routine for make_symbol_completion_list. */
2557 static int return_val_size;
2558 static int return_val_index;
2559 static char **return_val;
2561 #define COMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
2563 completion_list_add_name (SYMBOL_NAME (symbol), (sym_text), (len), \
2565 if (SYMBOL_DEMANGLED_NAME (symbol) != NULL) \
2566 completion_list_add_name \
2567 (SYMBOL_DEMANGLED_NAME (symbol), (sym_text), (len), (text), (word)); \
2570 /* Test to see if the symbol specified by SYMNAME (which is already
2571 demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
2572 characters. If so, add it to the current completion list. */
2575 completion_list_add_name (symname, sym_text, sym_text_len, text, word)
2585 /* clip symbols that cannot match */
2587 if (strncmp (symname, sym_text, sym_text_len) != 0)
2592 /* Clip any symbol names that we've already considered. (This is a
2593 time optimization) */
2595 for (i = 0; i < return_val_index; ++i)
2597 if (STREQ (symname, return_val[i]))
2603 /* We have a match for a completion, so add SYMNAME to the current list
2604 of matches. Note that the name is moved to freshly malloc'd space. */
2608 if (word == sym_text)
2610 new = xmalloc (strlen (symname) + 5);
2611 strcpy (new, symname);
2613 else if (word > sym_text)
2615 /* Return some portion of symname. */
2616 new = xmalloc (strlen (symname) + 5);
2617 strcpy (new, symname + (word - sym_text));
2621 /* Return some of SYM_TEXT plus symname. */
2622 new = xmalloc (strlen (symname) + (sym_text - word) + 5);
2623 strncpy (new, word, sym_text - word);
2624 new[sym_text - word] = '\0';
2625 strcat (new, symname);
2628 if (return_val_index + 3 > return_val_size)
2630 newsize = (return_val_size *= 2) * sizeof (char *);
2631 return_val = (char **) xrealloc ((char *) return_val, newsize);
2633 return_val[return_val_index++] = new;
2634 return_val[return_val_index] = NULL;
2638 /* Return a NULL terminated array of all symbols (regardless of class) which
2639 begin by matching TEXT. If the answer is no symbols, then the return value
2640 is an array which contains only a NULL pointer.
2642 Problem: All of the symbols have to be copied because readline frees them.
2643 I'm not going to worry about this; hopefully there won't be that many. */
2646 make_symbol_completion_list (text, word)
2650 register struct symbol *sym;
2651 register struct symtab *s;
2652 register struct partial_symtab *ps;
2653 register struct minimal_symbol *msymbol;
2654 register struct objfile *objfile;
2655 register struct block *b, *surrounding_static_block = 0;
2657 struct partial_symbol *psym;
2658 /* The symbol we are completing on. Points in same buffer as text. */
2660 /* Length of sym_text. */
2663 /* Now look for the symbol we are supposed to complete on.
2664 FIXME: This should be language-specific. */
2670 /* First see if this is a quoted string. */
2672 for (p = text; *p != '\0'; ++p)
2674 if (quote_found != '\0')
2676 if (*p == quote_found)
2677 /* Found close quote. */
2679 else if (*p == '\\' && p[1] == quote_found)
2680 /* A backslash followed by the quote character
2681 doesn't end the string. */
2684 else if (*p == '\'' || *p == '"')
2690 if (quote_found == '\'')
2691 /* A string within single quotes can be a symbol, so complete on it. */
2692 sym_text = quote_pos + 1;
2693 else if (quote_found == '"')
2694 /* A double-quoted string is never a symbol, nor does it make sense
2695 to complete it any other way. */
2699 /* It is not a quoted string. Break it based on the characters
2700 which are in symbols. */
2703 if (isalnum (p[-1]) || p[-1] == '_' || p[-1] == '\0')
2712 sym_text_len = strlen (sym_text);
2714 return_val_size = 100;
2715 return_val_index = 0;
2716 return_val = (char **) xmalloc ((return_val_size + 1) * sizeof (char *));
2717 return_val[0] = NULL;
2719 /* Look through the partial symtabs for all symbols which begin
2720 by matching SYM_TEXT. Add each one that you find to the list. */
2722 ALL_PSYMTABS (objfile, ps)
2724 /* If the psymtab's been read in we'll get it when we search
2725 through the blockvector. */
2726 if (ps->readin) continue;
2728 for (psym = objfile->global_psymbols.list + ps->globals_offset;
2729 psym < (objfile->global_psymbols.list + ps->globals_offset
2730 + ps->n_global_syms);
2733 /* If interrupted, then quit. */
2735 COMPLETION_LIST_ADD_SYMBOL (psym, sym_text, sym_text_len, text, word);
2738 for (psym = objfile->static_psymbols.list + ps->statics_offset;
2739 psym < (objfile->static_psymbols.list + ps->statics_offset
2740 + ps->n_static_syms);
2744 COMPLETION_LIST_ADD_SYMBOL (psym, sym_text, sym_text_len, text, word);
2748 /* At this point scan through the misc symbol vectors and add each
2749 symbol you find to the list. Eventually we want to ignore
2750 anything that isn't a text symbol (everything else will be
2751 handled by the psymtab code above). */
2753 ALL_MSYMBOLS (objfile, msymbol)
2756 COMPLETION_LIST_ADD_SYMBOL (msymbol, sym_text, sym_text_len, text, word);
2759 /* Search upwards from currently selected frame (so that we can
2760 complete on local vars. */
2762 for (b = get_selected_block (); b != NULL; b = BLOCK_SUPERBLOCK (b))
2764 if (!BLOCK_SUPERBLOCK (b))
2766 surrounding_static_block = b; /* For elmin of dups */
2769 /* Also catch fields of types defined in this places which match our
2770 text string. Only complete on types visible from current context. */
2772 for (i = 0; i < BLOCK_NSYMS (b); i++)
2774 sym = BLOCK_SYM (b, i);
2775 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
2776 if (SYMBOL_CLASS (sym) == LOC_TYPEDEF)
2778 struct type *t = SYMBOL_TYPE (sym);
2779 enum type_code c = TYPE_CODE (t);
2781 if (c == TYPE_CODE_UNION || c == TYPE_CODE_STRUCT)
2783 for (j = TYPE_N_BASECLASSES (t); j < TYPE_NFIELDS (t); j++)
2785 if (TYPE_FIELD_NAME (t, j))
2787 completion_list_add_name (TYPE_FIELD_NAME (t, j),
2788 sym_text, sym_text_len, text, word);
2796 /* Go through the symtabs and check the externs and statics for
2797 symbols which match. */
2799 ALL_SYMTABS (objfile, s)
2802 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
2803 for (i = 0; i < BLOCK_NSYMS (b); i++)
2805 sym = BLOCK_SYM (b, i);
2806 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
2810 ALL_SYMTABS (objfile, s)
2813 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
2814 /* Don't do this block twice. */
2815 if (b == surrounding_static_block) continue;
2816 for (i = 0; i < BLOCK_NSYMS (b); i++)
2818 sym = BLOCK_SYM (b, i);
2819 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
2823 return (return_val);
2828 /* Add the type of the symbol sym to the type of the current
2829 function whose block we are in (assumed). The type of
2830 this current function is contained in *TYPE.
2832 This basically works as follows: When we find a function
2833 symbol (N_FUNC with a 'f' or 'F' in the symbol name), we record
2834 a pointer to its type in the global in_function_type. Every
2835 time we come across a parameter symbol ('p' in its name), then
2836 this procedure adds the name and type of that parameter
2837 to the function type pointed to by *TYPE. (Which should correspond
2838 to in_function_type if it was called correctly).
2840 Note that since we are modifying a type, the result of
2841 lookup_function_type() should be memcpy()ed before calling
2842 this. When not in strict typing mode, the expression
2843 evaluator can choose to ignore this.
2845 Assumption: All of a function's parameter symbols will
2846 appear before another function symbol is found. The parameters
2847 appear in the same order in the argument list as they do in the
2851 add_param_to_type (type,sym)
2855 int num = ++(TYPE_NFIELDS(*type));
2857 if(TYPE_NFIELDS(*type)-1)
2858 TYPE_FIELDS(*type) = (struct field *)
2859 (*current_objfile->xrealloc) ((char *)(TYPE_FIELDS(*type)),
2860 num*sizeof(struct field));
2862 TYPE_FIELDS(*type) = (struct field *)
2863 (*current_objfile->xmalloc) (num*sizeof(struct field));
2865 TYPE_FIELD_BITPOS(*type,num-1) = num-1;
2866 TYPE_FIELD_BITSIZE(*type,num-1) = 0;
2867 TYPE_FIELD_TYPE(*type,num-1) = SYMBOL_TYPE(sym);
2868 TYPE_FIELD_NAME(*type,num-1) = SYMBOL_NAME(sym);
2873 _initialize_symtab ()
2875 add_info ("variables", variables_info,
2876 "All global and static variable names, or those matching REGEXP.");
2877 add_info ("functions", functions_info,
2878 "All function names, or those matching REGEXP.");
2880 /* FIXME: This command has at least the following problems:
2881 1. It prints builtin types (in a very strange and confusing fashion).
2882 2. It doesn't print right, e.g. with
2883 typedef struct foo *FOO
2884 type_print prints "FOO" when we want to make it (in this situation)
2885 print "struct foo *".
2886 I also think "ptype" or "whatis" is more likely to be useful (but if
2887 there is much disagreement "info types" can be fixed). */
2888 add_info ("types", types_info,
2889 "All type names, or those matching REGEXP.");
2892 add_info ("methods", methods_info,
2893 "All method names, or those matching REGEXP::REGEXP.\n\
2894 If the class qualifier is omitted, it is assumed to be the current scope.\n\
2895 If the first REGEXP is omitted, then all methods matching the second REGEXP\n\
2898 add_info ("sources", sources_info,
2899 "Source files in the program.");
2901 add_com ("rbreak", no_class, rbreak_command,
2902 "Set a breakpoint for all functions matching REGEXP.");
2904 /* Initialize the one built-in type that isn't language dependent... */
2905 builtin_type_error = init_type (TYPE_CODE_ERROR, 0, 0,
2906 "<unknown type>", (struct objfile *) NULL);