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 *));
54 static struct symtabs_and_lines
55 decode_line_2
PARAMS ((struct symbol
*[], int, int));
58 rbreak_command
PARAMS ((char *, int));
61 types_info
PARAMS ((char *, int));
64 functions_info
PARAMS ((char *, int));
67 variables_info
PARAMS ((char *, int));
70 sources_info
PARAMS ((char *, int));
73 list_symbols
PARAMS ((char *, int, int));
76 output_source_filename
PARAMS ((char *, int *));
79 operator_chars
PARAMS ((char *, char **));
82 find_line_common
PARAMS ((struct linetable
*, int, int *));
84 static struct partial_symbol
*
85 lookup_partial_symbol
PARAMS ((struct partial_symtab
*, const char *,
86 int, enum namespace));
88 static struct symtab
*
89 lookup_symtab_1
PARAMS ((char *));
93 /* The single non-language-specific builtin type */
94 struct type
*builtin_type_error
;
96 /* Block in which the most recently searched-for symbol was found.
97 Might be better to make this a parameter to lookup_symbol and
100 const struct block
*block_found
;
102 char no_symtab_msg
[] = "No symbol table is loaded. Use the \"file\" command.";
104 /* While the C++ support is still in flux, issue a possibly helpful hint on
105 using the new command completion feature on single quoted demangled C++
106 symbols. Remove when loose ends are cleaned up. FIXME -fnf */
109 cplusplus_hint (name
)
112 printf ("Hint: try '%s<TAB> or '%s<ESC-?>\n", name
, name
);
113 printf ("(Note leading single quote.)\n");
116 /* Check for a symtab of a specific name; first in symtabs, then in
117 psymtabs. *If* there is no '/' in the name, a match after a '/'
118 in the symtab filename will also work. */
120 static struct symtab
*
121 lookup_symtab_1 (name
)
124 register struct symtab
*s
;
125 register struct partial_symtab
*ps
;
126 register char *slash
;
127 register struct objfile
*objfile
;
131 /* First, search for an exact match */
133 ALL_SYMTABS (objfile
, s
)
134 if (STREQ (name
, s
->filename
))
137 slash
= strchr (name
, '/');
139 /* Now, search for a matching tail (only if name doesn't have any dirs) */
142 ALL_SYMTABS (objfile
, s
)
144 char *p
= s
-> filename
;
145 char *tail
= strrchr (p
, '/');
154 /* Same search rules as above apply here, but now we look thru the
157 ALL_PSYMTABS (objfile
, ps
)
158 if (STREQ (name
, ps
-> filename
))
162 ALL_PSYMTABS (objfile
, ps
)
164 char *p
= ps
-> filename
;
165 char *tail
= strrchr (p
, '/');
179 error ("Internal: readin %s pst for `%s' found when no symtab found.",
180 ps
-> filename
, name
);
182 s
= PSYMTAB_TO_SYMTAB (ps
);
187 /* At this point, we have located the psymtab for this file, but
188 the conversion to a symtab has failed. This usually happens
189 when we are looking up an include file. In this case,
190 PSYMTAB_TO_SYMTAB doesn't return a symtab, even though one has
191 been created. So, we need to run through the symtabs again in
192 order to find the file.
193 XXX - This is a crock, and should be fixed inside of the the
194 symbol parsing routines. */
198 /* Lookup the symbol table of a source file named NAME. Try a couple
199 of variations if the first lookup doesn't work. */
205 register struct symtab
*s
;
208 s
= lookup_symtab_1 (name
);
211 /* If name not found as specified, see if adding ".c" helps. */
213 copy
= (char *) alloca (strlen (name
) + 3);
216 s
= lookup_symtab_1 (copy
);
219 /* We didn't find anything; die. */
223 /* Lookup the partial symbol table of a source file named NAME. This
224 only returns true on an exact match (ie. this semantics are
225 different from lookup_symtab. */
227 struct partial_symtab
*
228 lookup_partial_symtab (name
)
231 register struct partial_symtab
*pst
;
232 register struct objfile
*objfile
;
234 ALL_PSYMTABS (objfile
, pst
)
236 if (STREQ (name
, pst
-> filename
))
244 /* Demangle a GDB method stub type.
245 Note that this function is g++ specific. */
248 gdb_mangle_name (type
, i
, j
)
252 int mangled_name_len
;
254 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
255 struct fn_field
*method
= &f
[j
];
256 char *field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
257 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
258 char *newname
= type_name_no_tag (type
);
259 int is_constructor
= STREQ (field_name
, newname
);
260 int is_destructor
= is_constructor
&& DESTRUCTOR_PREFIX_P (physname
);
261 /* Need a new type prefix. */
262 char *const_prefix
= method
->is_const
? "C" : "";
263 char *volatile_prefix
= method
->is_volatile
? "V" : "";
265 #ifndef GCC_MANGLE_BUG
266 int len
= strlen (newname
);
270 mangled_name
= (char*) xmalloc(strlen(physname
)+1);
271 strcpy(mangled_name
, physname
);
275 sprintf (buf
, "__%s%s%d", const_prefix
, volatile_prefix
, len
);
276 mangled_name_len
= ((is_constructor
? 0 : strlen (field_name
))
281 /* Only needed for GNU-mangled names. ANSI-mangled names
282 work with the normal mechanisms. */
283 if (OPNAME_PREFIX_P (field_name
))
285 char *opname
= cplus_mangle_opname (field_name
+ 3, 0);
287 error ("No mangling for \"%s\"", field_name
);
288 mangled_name_len
+= strlen (opname
);
289 mangled_name
= (char *)xmalloc (mangled_name_len
);
291 strncpy (mangled_name
, field_name
, 3);
292 mangled_name
[3] = '\0';
293 strcat (mangled_name
, opname
);
297 mangled_name
= (char *)xmalloc (mangled_name_len
);
299 mangled_name
[0] = '\0';
301 strcpy (mangled_name
, field_name
);
303 strcat (mangled_name
, buf
);
304 strcat (mangled_name
, newname
);
314 sprintf (buf
, "__%s%s", const_prefix
, volatile_prefix
);
317 mangled_name_len
= ((is_constructor
? 0 : strlen (field_name
))
318 + strlen (buf
) + strlen (physname
) + 1);
320 /* Only needed for GNU-mangled names. ANSI-mangled names
321 work with the normal mechanisms. */
322 if (OPNAME_PREFIX_P (field_name
))
324 opname
= cplus_mangle_opname (field_name
+ 3, 0);
327 error ("No mangling for \"%s\"", field_name
);
329 mangled_name_len
+= strlen (opname
);
330 mangled_name
= (char *) xmalloc (mangled_name_len
);
332 strncpy (mangled_name
, field_name
, 3);
333 strcpy (mangled_name
+ 3, opname
);
337 mangled_name
= (char *) xmalloc (mangled_name_len
);
340 mangled_name
[0] = '\0';
344 strcpy (mangled_name
, field_name
);
347 strcat (mangled_name
, buf
);
350 strcat (mangled_name
, physname
);
351 return (mangled_name
);
355 /* Find which partial symtab on contains PC. Return 0 if none. */
357 struct partial_symtab
*
359 register CORE_ADDR pc
;
361 register struct partial_symtab
*pst
;
362 register struct objfile
*objfile
;
364 ALL_PSYMTABS (objfile
, pst
)
366 if (pc
>= pst
->textlow
&& pc
< pst
->texthigh
)
372 /* Find which partial symbol within a psymtab contains PC. Return 0
373 if none. Check all psymtabs if PSYMTAB is 0. */
374 struct partial_symbol
*
375 find_pc_psymbol (psymtab
, pc
)
376 struct partial_symtab
*psymtab
;
379 struct partial_symbol
*best
, *p
;
383 psymtab
= find_pc_psymtab (pc
);
387 best_pc
= psymtab
->textlow
- 1;
389 for (p
= psymtab
->objfile
->static_psymbols
.list
+ psymtab
->statics_offset
;
390 (p
- (psymtab
->objfile
->static_psymbols
.list
+ psymtab
->statics_offset
)
391 < psymtab
->n_static_syms
);
393 if (SYMBOL_NAMESPACE (p
) == VAR_NAMESPACE
394 && SYMBOL_CLASS (p
) == LOC_BLOCK
395 && pc
>= SYMBOL_VALUE_ADDRESS (p
)
396 && SYMBOL_VALUE_ADDRESS (p
) > best_pc
)
398 best_pc
= SYMBOL_VALUE_ADDRESS (p
);
401 if (best_pc
== psymtab
->textlow
- 1)
407 /* Find the definition for a specified symbol name NAME
408 in namespace NAMESPACE, visible from lexical block BLOCK.
409 Returns the struct symbol pointer, or zero if no symbol is found.
410 If SYMTAB is non-NULL, store the symbol table in which the
411 symbol was found there, or NULL if not found.
412 C++: if IS_A_FIELD_OF_THIS is nonzero on entry, check to see if
413 NAME is a field of the current implied argument `this'. If so set
414 *IS_A_FIELD_OF_THIS to 1, otherwise set it to zero.
415 BLOCK_FOUND is set to the block in which NAME is found (in the case of
416 a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */
419 lookup_symbol (name
, block
, namespace, is_a_field_of_this
, symtab
)
421 register const struct block
*block
;
422 const enum namespace namespace;
423 int *is_a_field_of_this
;
424 struct symtab
**symtab
;
426 register struct symbol
*sym
;
427 register struct symtab
*s
;
428 register struct partial_symtab
*ps
;
429 struct blockvector
*bv
;
430 register struct objfile
*objfile
;
431 register struct block
*b
;
432 register struct minimal_symbol
*msymbol
;
434 extern char *gdb_completer_word_break_characters
;
436 /* Search specified block and its superiors. */
440 sym
= lookup_block_symbol (block
, name
, namespace);
446 /* Search the list of symtabs for one which contains the
447 address of the start of this block. */
448 ALL_SYMTABS (objfile
, s
)
450 bv
= BLOCKVECTOR (s
);
451 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
452 if (BLOCK_START (b
) <= BLOCK_START (block
)
453 && BLOCK_END (b
) > BLOCK_START (block
))
462 block
= BLOCK_SUPERBLOCK (block
);
465 /* FIXME: this code is never executed--block is always NULL at this
466 point. What is it trying to do, anyway? We already should have
467 checked the STATIC_BLOCK above (it is the superblock of top-level
468 blocks). Why is VAR_NAMESPACE special-cased? */
469 /* Don't need to mess with the psymtabs; if we have a block,
470 that file is read in. If we don't, then we deal later with
471 all the psymtab stuff that needs checking. */
472 if (namespace == VAR_NAMESPACE
&& block
!= NULL
)
475 /* Find the right symtab. */
476 ALL_SYMTABS (objfile
, s
)
478 bv
= BLOCKVECTOR (s
);
479 b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
480 if (BLOCK_START (b
) <= BLOCK_START (block
)
481 && BLOCK_END (b
) > BLOCK_START (block
))
483 sym
= lookup_block_symbol (b
, name
, VAR_NAMESPACE
);
496 /* C++: If requested to do so by the caller,
497 check to see if NAME is a field of `this'. */
498 if (is_a_field_of_this
)
500 struct value
*v
= value_of_this (0);
502 *is_a_field_of_this
= 0;
503 if (v
&& check_field (v
, name
))
505 *is_a_field_of_this
= 1;
512 /* Now search all global blocks. Do the symtab's first, then
513 check the psymtab's */
515 ALL_SYMTABS (objfile
, s
)
517 bv
= BLOCKVECTOR (s
);
518 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
519 sym
= lookup_block_symbol (block
, name
, namespace);
529 /* Check for the possibility of the symbol being a global function
530 that is stored in one of the minimal symbol tables. Eventually, all
531 global symbols might be resolved in this way. */
533 if (namespace == VAR_NAMESPACE
)
535 msymbol
= lookup_minimal_symbol (name
, (struct objfile
*) NULL
);
538 s
= find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
));
539 /* If S is NULL, there are no debug symbols for this file.
540 Skip this stuff and check for matching static symbols below. */
543 bv
= BLOCKVECTOR (s
);
544 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
545 sym
= lookup_block_symbol (block
, SYMBOL_NAME (msymbol
),
547 /* We kept static functions in minimal symbol table as well as
548 in static scope. We want to find them in the symbol table. */
550 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
551 sym
= lookup_block_symbol (block
, SYMBOL_NAME (msymbol
),
555 /* sym == 0 if symbol was found in the minimal symbol table
556 but not in the symtab.
557 Return 0 to use the msymbol definition of "foo_".
559 This happens for Fortran "foo_" symbols,
560 which are "foo" in the symtab.
562 This can also happen if "asm" is used to make a
563 regular symbol but not a debugging symbol, e.g.
575 ALL_PSYMTABS (objfile
, ps
)
577 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 1, namespace))
579 s
= PSYMTAB_TO_SYMTAB(ps
);
580 bv
= BLOCKVECTOR (s
);
581 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
582 sym
= lookup_block_symbol (block
, name
, namespace);
584 error ("Internal: global symbol `%s' found in %s psymtab but not in symtab", name
, ps
->filename
);
591 /* Now search all per-file blocks.
592 Not strictly correct, but more useful than an error.
593 Do the symtabs first, then check the psymtabs */
595 ALL_SYMTABS (objfile
, s
)
597 bv
= BLOCKVECTOR (s
);
598 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
599 sym
= lookup_block_symbol (block
, name
, namespace);
609 ALL_PSYMTABS (objfile
, ps
)
611 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 0, namespace))
613 s
= PSYMTAB_TO_SYMTAB(ps
);
614 bv
= BLOCKVECTOR (s
);
615 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
616 sym
= lookup_block_symbol (block
, name
, namespace);
618 error ("Internal: static symbol `%s' found in %s psymtab but not in symtab", name
, ps
->filename
);
625 /* Now search all per-file blocks for static mangled symbols.
626 Do the symtabs first, then check the psymtabs. */
628 if (namespace == VAR_NAMESPACE
)
630 ALL_SYMTABS (objfile
, s
)
632 bv
= BLOCKVECTOR (s
);
633 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
634 sym
= lookup_block_symbol (block
, name
, VAR_NAMESPACE
);
644 ALL_PSYMTABS (objfile
, ps
)
646 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 0, VAR_NAMESPACE
))
648 s
= PSYMTAB_TO_SYMTAB(ps
);
649 bv
= BLOCKVECTOR (s
);
650 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
651 sym
= lookup_block_symbol (block
, name
, VAR_NAMESPACE
);
653 error ("Internal: mangled static symbol `%s' found in %s psymtab but not in symtab", name
, ps
->filename
);
666 /* Look, in partial_symtab PST, for symbol NAME. Check the global
667 symbols if GLOBAL, the static symbols if not */
669 static struct partial_symbol
*
670 lookup_partial_symbol (pst
, name
, global
, namespace)
671 struct partial_symtab
*pst
;
674 enum namespace namespace;
676 struct partial_symbol
*start
, *psym
;
677 struct partial_symbol
*top
, *bottom
, *center
;
678 int length
= (global
? pst
->n_global_syms
: pst
->n_static_syms
);
679 int do_linear_search
= 1;
687 pst
->objfile
->global_psymbols
.list
+ pst
->globals_offset
:
688 pst
->objfile
->static_psymbols
.list
+ pst
->statics_offset
);
690 if (global
) /* This means we can use a binary search. */
692 do_linear_search
= 0;
694 /* Binary search. This search is guaranteed to end with center
695 pointing at the earliest partial symbol with the correct
696 name. At that point *all* partial symbols with that name
697 will be checked against the correct namespace. */
700 top
= start
+ length
- 1;
703 center
= bottom
+ (top
- bottom
) / 2;
704 assert (center
< top
);
705 if (!do_linear_search
&& SYMBOL_LANGUAGE (center
) == language_cplus
)
707 do_linear_search
= 1;
709 if (STRCMP (SYMBOL_NAME (center
), name
) >= 0)
718 assert (top
== bottom
);
719 while (STREQ (SYMBOL_NAME (top
), name
))
721 if (SYMBOL_NAMESPACE (top
) == namespace)
729 /* Can't use a binary search or else we found during the binary search that
730 we should also do a linear search. */
732 if (do_linear_search
)
734 for (psym
= start
; psym
< start
+ length
; psym
++)
736 if (namespace == SYMBOL_NAMESPACE (psym
))
738 if (SYMBOL_MATCHES_NAME (psym
, name
))
749 /* Find the psymtab containing main(). */
750 /* FIXME: What about languages without main() or specially linked
751 executables that have no main() ? */
753 struct partial_symtab
*
756 register struct partial_symtab
*pst
;
757 register struct objfile
*objfile
;
759 ALL_PSYMTABS (objfile
, pst
)
761 if (lookup_partial_symbol (pst
, "main", 1, VAR_NAMESPACE
))
769 /* Search BLOCK for symbol NAME in NAMESPACE.
771 Note that if NAME is the demangled form of a C++ symbol, we will fail
772 to find a match during the binary search of the non-encoded names, but
773 for now we don't worry about the slight inefficiency of looking for
774 a match we'll never find, since it will go pretty quick. Once the
775 binary search terminates, we drop through and do a straight linear
776 search on the symbols. Each symbol which is marked as being a C++
777 symbol (language_cplus set) has both the encoded and non-encoded names
778 tested for a match. */
781 lookup_block_symbol (block
, name
, namespace)
782 register const struct block
*block
;
784 const enum namespace namespace;
786 register int bot
, top
, inc
;
787 register struct symbol
*sym
;
788 register struct symbol
*sym_found
= NULL
;
789 register int do_linear_search
= 1;
791 /* If the blocks's symbols were sorted, start with a binary search. */
793 if (BLOCK_SHOULD_SORT (block
))
795 /* Reset the linear search flag so if the binary search fails, we
796 won't do the linear search once unless we find some reason to
797 do so, such as finding a C++ symbol during the binary search.
798 Note that for C++ modules, ALL the symbols in a block should
799 end up marked as C++ symbols. */
801 do_linear_search
= 0;
802 top
= BLOCK_NSYMS (block
);
805 /* Advance BOT to not far before the first symbol whose name is NAME. */
809 inc
= (top
- bot
+ 1);
810 /* No need to keep binary searching for the last few bits worth. */
815 inc
= (inc
>> 1) + bot
;
816 sym
= BLOCK_SYM (block
, inc
);
817 if (!do_linear_search
&& SYMBOL_LANGUAGE (sym
) == language_cplus
)
819 do_linear_search
= 1;
821 if (SYMBOL_NAME (sym
)[0] < name
[0])
825 else if (SYMBOL_NAME (sym
)[0] > name
[0])
829 else if (STRCMP (SYMBOL_NAME (sym
), name
) < 0)
839 /* Now scan forward until we run out of symbols, find one whose
840 name is greater than NAME, or find one we want. If there is
841 more than one symbol with the right name and namespace, we
842 return the first one; I believe it is now impossible for us
843 to encounter two symbols with the same name and namespace
844 here, because blocks containing argument symbols are no
847 top
= BLOCK_NSYMS (block
);
850 sym
= BLOCK_SYM (block
, bot
);
851 inc
= SYMBOL_NAME (sym
)[0] - name
[0];
854 inc
= STRCMP (SYMBOL_NAME (sym
), name
);
856 if (inc
== 0 && SYMBOL_NAMESPACE (sym
) == namespace)
868 /* Here if block isn't sorted, or we fail to find a match during the
869 binary search above. If during the binary search above, we find a
870 symbol which is a C++ symbol, then we have re-enabled the linear
871 search flag which was reset when starting the binary search.
873 This loop is equivalent to the loop above, but hacked greatly for speed.
875 Note that parameter symbols do not always show up last in the
876 list; this loop makes sure to take anything else other than
877 parameter symbols first; it only uses parameter symbols as a
878 last resort. Note that this only takes up extra computation
881 if (do_linear_search
)
883 top
= BLOCK_NSYMS (block
);
887 sym
= BLOCK_SYM (block
, bot
);
888 if (SYMBOL_NAMESPACE (sym
) == namespace &&
889 SYMBOL_MATCHES_NAME (sym
, name
))
892 if (SYMBOL_CLASS (sym
) != LOC_ARG
&&
893 SYMBOL_CLASS (sym
) != LOC_LOCAL_ARG
&&
894 SYMBOL_CLASS (sym
) != LOC_REF_ARG
&&
895 SYMBOL_CLASS (sym
) != LOC_REGPARM
&&
896 SYMBOL_CLASS (sym
) != LOC_REGPARM_ADDR
)
904 return (sym_found
); /* Will be NULL if not found. */
908 /* Return the symbol for the function which contains a specified
909 lexical block, described by a struct block BL. */
915 while (BLOCK_FUNCTION (bl
) == 0 && BLOCK_SUPERBLOCK (bl
) != 0)
916 bl
= BLOCK_SUPERBLOCK (bl
);
918 return BLOCK_FUNCTION (bl
);
921 /* Find the symtab associated with PC. Look through the psymtabs and read in
922 another symtab if necessary. */
926 register CORE_ADDR pc
;
928 register struct block
*b
;
929 struct blockvector
*bv
;
930 register struct symtab
*s
= NULL
;
931 register struct symtab
*best_s
= NULL
;
932 register struct partial_symtab
*ps
;
933 register struct objfile
*objfile
;
937 /* Search all symtabs for one whose file contains our pc */
939 ALL_SYMTABS (objfile
, s
)
941 bv
= BLOCKVECTOR (s
);
942 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
943 if (BLOCK_START (b
) <= pc
944 && BLOCK_END (b
) > pc
946 || BLOCK_END (b
) - BLOCK_START (b
) < distance
))
948 distance
= BLOCK_END (b
) - BLOCK_START (b
);
957 ps
= find_pc_psymtab (pc
);
961 printf_filtered ("(Internal error: pc 0x%x in read in psymtab, but not in symtab.)\n", pc
);
962 s
= PSYMTAB_TO_SYMTAB (ps
);
967 /* Find the source file and line number for a given PC value.
968 Return a structure containing a symtab pointer, a line number,
969 and a pc range for the entire source line.
970 The value's .pc field is NOT the specified pc.
971 NOTCURRENT nonzero means, if specified pc is on a line boundary,
972 use the line that ends there. Otherwise, in that case, the line
973 that begins there is used. */
975 /* The big complication here is that a line may start in one file, and end just
976 before the start of another file. This usually occurs when you #include
977 code in the middle of a subroutine. To properly find the end of a line's PC
978 range, we must search all symtabs associated with this compilation unit, and
979 find the one whose first PC is closer than that of the next line in this
982 FIXME: We used to complain here about zero length or negative length line
983 tables, but there are two problems with this: (1) some symtabs may not have
984 any line numbers due to gcc -g1 compilation, and (2) this function is called
985 during single stepping, when we don't own the terminal and thus can't
986 produce any output. One solution might be to implement a mechanism whereby
987 complaints can be queued until we regain control of the terminal. -fnf
990 struct symtab_and_line
991 find_pc_line (pc
, notcurrent
)
996 register struct linetable
*l
;
999 register struct linetable_entry
*item
;
1000 struct symtab_and_line val
;
1001 struct blockvector
*bv
;
1003 /* Info on best line seen so far, and where it starts, and its file. */
1005 struct linetable_entry
*best
= NULL
;
1006 CORE_ADDR best_end
= 0;
1007 struct symtab
*best_symtab
= 0;
1009 /* Store here the first line number
1010 of a file which contains the line at the smallest pc after PC.
1011 If we don't find a line whose range contains PC,
1012 we will use a line one less than this,
1013 with a range from the start of that file to the first line's pc. */
1014 struct linetable_entry
*alt
= NULL
;
1015 struct symtab
*alt_symtab
= 0;
1017 /* Info on best line seen in this file. */
1019 struct linetable_entry
*prev
;
1021 /* If this pc is not from the current frame,
1022 it is the address of the end of a call instruction.
1023 Quite likely that is the start of the following statement.
1024 But what we want is the statement containing the instruction.
1025 Fudge the pc to make sure we get that. */
1027 if (notcurrent
) pc
-= 1;
1029 s
= find_pc_symtab (pc
);
1039 bv
= BLOCKVECTOR (s
);
1041 /* Look at all the symtabs that share this blockvector.
1042 They all have the same apriori range, that we found was right;
1043 but they have different line tables. */
1045 for (; s
&& BLOCKVECTOR (s
) == bv
; s
= s
->next
)
1047 /* Find the best line in this symtab. */
1052 if (len
<= 0) /* See FIXME above. */
1058 item
= l
->item
; /* Get first line info */
1060 /* Is this file's first line closer than the first lines of other files?
1061 If so, record this file, and its first line, as best alternate. */
1062 if (item
->pc
> pc
&& (!alt
|| item
->pc
< alt
->pc
))
1068 for (i
= 0; i
< len
; i
++, item
++)
1070 /* Return the last line that did not start after PC. */
1077 /* At this point, prev points at the line whose start addr is <= pc, and
1078 item points at the next line. If we ran off the end of the linetable
1079 (pc >= start of the last line), then prev == item. If pc < start of
1080 the first line, prev will not be set. */
1082 /* Is this file's best line closer than the best in the other files?
1083 If so, record this file, and its best line, as best so far. */
1085 if (prev
&& (!best
|| prev
->pc
> best
->pc
))
1089 /* If another line is in the linetable, and its PC is closer
1090 than the best_end we currently have, take it as best_end. */
1091 if (i
< len
&& (best_end
== 0 || best_end
> item
->pc
))
1092 best_end
= item
->pc
;
1099 { /* If we didn't find any line # info, just
1108 val
.symtab
= alt_symtab
;
1109 val
.line
= alt
->line
- 1;
1110 val
.pc
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
1116 val
.symtab
= best_symtab
;
1117 val
.line
= best
->line
;
1119 if (best_end
&& (!alt
|| best_end
< alt
->pc
))
1124 val
.end
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
1129 /* Find the PC value for a given source file and line number.
1130 Returns zero for invalid line number.
1131 The source file is specified with a struct symtab. */
1134 find_line_pc (symtab
, line
)
1135 struct symtab
*symtab
;
1138 register struct linetable
*l
;
1144 l
= LINETABLE (symtab
);
1145 ind
= find_line_common(l
, line
, &dummy
);
1146 return (ind
>= 0) ? l
->item
[ind
].pc
: 0;
1149 /* Find the range of pc values in a line.
1150 Store the starting pc of the line into *STARTPTR
1151 and the ending pc (start of next line) into *ENDPTR.
1152 Returns 1 to indicate success.
1153 Returns 0 if could not find the specified line. */
1156 find_line_pc_range (symtab
, thisline
, startptr
, endptr
)
1157 struct symtab
*symtab
;
1159 CORE_ADDR
*startptr
, *endptr
;
1161 register struct linetable
*l
;
1163 int exact_match
; /* did we get an exact linenumber match */
1168 l
= LINETABLE (symtab
);
1169 ind
= find_line_common (l
, thisline
, &exact_match
);
1172 *startptr
= l
->item
[ind
].pc
;
1173 /* If we have not seen an entry for the specified line,
1174 assume that means the specified line has zero bytes. */
1175 if (!exact_match
|| ind
== l
->nitems
-1)
1176 *endptr
= *startptr
;
1178 /* Perhaps the following entry is for the following line.
1179 It's worth a try. */
1180 if (ind
+1 < l
->nitems
1181 && l
->item
[ind
+1].line
== thisline
+ 1)
1182 *endptr
= l
->item
[ind
+1].pc
;
1184 *endptr
= find_line_pc (symtab
, thisline
+1);
1191 /* Given a line table and a line number, return the index into the line
1192 table for the pc of the nearest line whose number is >= the specified one.
1193 Return -1 if none is found. The value is >= 0 if it is an index.
1195 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
1198 find_line_common (l
, lineno
, exact_match
)
1199 register struct linetable
*l
;
1200 register int lineno
;
1206 /* BEST is the smallest linenumber > LINENO so far seen,
1207 or 0 if none has been seen so far.
1208 BEST_INDEX identifies the item for it. */
1210 int best_index
= -1;
1219 for (i
= 0; i
< len
; i
++)
1221 register struct linetable_entry
*item
= &(l
->item
[i
]);
1223 if (item
->line
== lineno
)
1229 if (item
->line
> lineno
&& (best
== 0 || item
->line
< best
))
1236 /* If we got here, we didn't get an exact match. */
1243 find_pc_line_pc_range (pc
, startptr
, endptr
)
1245 CORE_ADDR
*startptr
, *endptr
;
1247 struct symtab_and_line sal
;
1248 sal
= find_pc_line (pc
, 0);
1251 return sal
.symtab
!= 0;
1254 /* If P is of the form "operator[ \t]+..." where `...' is
1255 some legitimate operator text, return a pointer to the
1256 beginning of the substring of the operator text.
1257 Otherwise, return "". */
1259 operator_chars (p
, end
)
1264 if (strncmp (p
, "operator", 8))
1268 /* Don't get faked out by `operator' being part of a longer
1270 if (isalpha(*p
) || *p
== '_' || *p
== '$' || *p
== '\0')
1273 /* Allow some whitespace between `operator' and the operator symbol. */
1274 while (*p
== ' ' || *p
== '\t')
1277 /* Recognize 'operator TYPENAME'. */
1279 if (isalpha(*p
) || *p
== '_' || *p
== '$')
1281 register char *q
= p
+1;
1282 while (isalnum(*q
) || *q
== '_' || *q
== '$')
1307 if (p
[1] == '=' || p
[1] == p
[0])
1318 error ("`operator ()' must be specified without whitespace in `()'");
1323 error ("`operator ?:' must be specified without whitespace in `?:'");
1328 error ("`operator []' must be specified without whitespace in `[]'");
1332 error ("`operator %s' not supported", p
);
1339 /* Recursive helper function for decode_line_1.
1340 * Look for methods named NAME in type T.
1341 * Return number of matches.
1342 * Put matches in SYM_ARR (which better be big enough!).
1343 * These allocations seem to define "big enough":
1344 * sym_arr = (struct symbol **) alloca(TYPE_NFN_FIELDS_TOTAL (t) * sizeof(struct symbol*));
1345 * Note that this function is g++ specific.
1349 find_methods (t
, name
, sym_arr
)
1352 struct symbol
**sym_arr
;
1356 struct symbol
*sym_class
;
1357 char *class_name
= type_name_no_tag (t
);
1358 /* Ignore this class if it doesn't have a name.
1359 This prevents core dumps, but is just a workaround
1360 because we might not find the function in
1361 certain cases, such as
1362 struct D {virtual int f();}
1363 struct C : D {virtual int g();}
1364 (in this case g++ 1.35.1- does not put out a name
1365 for D as such, it defines type 19 (for example) in
1366 the same stab as C, and then does a
1367 .stabs "D:T19" and a .stabs "D:t19".
1369 "break C::f" should not be looking for field f in
1371 but just for the field f in the baseclasses of C
1372 (no matter what their names).
1374 However, I don't know how to replace the code below
1375 that depends on knowing the name of D. */
1377 && (sym_class
= lookup_symbol (class_name
,
1378 (struct block
*)NULL
,
1381 (struct symtab
**)NULL
)))
1384 t
= SYMBOL_TYPE (sym_class
);
1385 for (method_counter
= TYPE_NFN_FIELDS (t
) - 1;
1386 method_counter
>= 0;
1390 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, method_counter
);
1392 char *method_name
= TYPE_FN_FIELDLIST_NAME (t
, method_counter
);
1393 if (STREQ (name
, method_name
))
1394 /* Find all the fields with that name. */
1395 for (field_counter
= TYPE_FN_FIELDLIST_LENGTH (t
, method_counter
) - 1;
1400 if (TYPE_FN_FIELD_STUB (f
, field_counter
))
1401 check_stub_method (t
, method_counter
, field_counter
);
1402 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, field_counter
);
1403 /* Destructor is handled by caller, dont add it to the list */
1404 if (DESTRUCTOR_PREFIX_P (phys_name
))
1406 sym_arr
[i1
] = lookup_symbol (phys_name
,
1407 SYMBOL_BLOCK_VALUE (sym_class
),
1410 (struct symtab
**) NULL
);
1411 if (sym_arr
[i1
]) i1
++;
1414 fputs_filtered("(Cannot find method ", stdout
);
1415 fprintf_symbol_filtered (stdout
, phys_name
,
1416 language_cplus
, DMGL_PARAMS
);
1417 fputs_filtered(" - possibly inlined.)\n", stdout
);
1422 /* Only search baseclasses if there is no match yet,
1423 * since names in derived classes override those in baseclasses.
1427 for (ibase
= 0; ibase
< TYPE_N_BASECLASSES (t
); ibase
++)
1428 i1
+= find_methods(TYPE_BASECLASS(t
, ibase
), name
,
1433 /* Parse a string that specifies a line number.
1434 Pass the address of a char * variable; that variable will be
1435 advanced over the characters actually parsed.
1439 LINENUM -- that line number in current file. PC returned is 0.
1440 FILE:LINENUM -- that line in that file. PC returned is 0.
1441 FUNCTION -- line number of openbrace of that function.
1442 PC returned is the start of the function.
1443 VARIABLE -- line number of definition of that variable.
1445 FILE:FUNCTION -- likewise, but prefer functions in that file.
1446 *EXPR -- line in which address EXPR appears.
1448 FUNCTION may be an undebuggable function found in minimal symbol table.
1450 If the argument FUNFIRSTLINE is nonzero, we want the first line
1451 of real code inside a function when a function is specified.
1453 DEFAULT_SYMTAB specifies the file to use if none is specified.
1454 It defaults to current_source_symtab.
1455 DEFAULT_LINE specifies the line number to use for relative
1456 line numbers (that start with signs). Defaults to current_source_line.
1458 Note that it is possible to return zero for the symtab
1459 if no file is validly specified. Callers must check that.
1460 Also, the line number returned may be invalid. */
1462 struct symtabs_and_lines
1463 decode_line_1 (argptr
, funfirstline
, default_symtab
, default_line
)
1466 struct symtab
*default_symtab
;
1469 struct symtabs_and_lines values
;
1470 #ifdef HPPA_COMPILER_BUG
1471 /* FIXME: The native HP 9000/700 compiler has a bug which appears
1472 when optimizing this file with target i960-vxworks. I haven't
1473 been able to construct a simple test case. The problem is that
1474 in the second call to SKIP_PROLOGUE below, the compiler somehow
1475 does not realize that the statement val = find_pc_line (...) will
1476 change the values of the fields of val. It extracts the elements
1477 into registers at the top of the block, and does not update the
1478 registers after the call to find_pc_line. You can check this by
1479 inserting a printf at the end of find_pc_line to show what values
1480 it is returning for val.pc and val.end and another printf after
1481 the call to see what values the function actually got (remember,
1482 this is compiling with cc -O, with this patch removed). You can
1483 also examine the assembly listing: search for the second call to
1484 skip_prologue; the LDO statement before the next call to
1485 find_pc_line loads the address of the structure which
1486 find_pc_line will return; if there is a LDW just before the LDO,
1487 which fetches an element of the structure, then the compiler
1490 Setting val to volatile avoids the problem. We must undef
1491 volatile, because the HPPA native compiler does not define
1492 __STDC__, although it does understand volatile, and so volatile
1493 will have been defined away in defs.h. */
1495 volatile struct symtab_and_line val
;
1496 #define volatile /*nothing*/
1498 struct symtab_and_line val
;
1500 register char *p
, *p1
;
1502 register struct symtab
*s
;
1504 register struct symbol
*sym
;
1505 /* The symtab that SYM was found in. */
1506 struct symtab
*sym_symtab
;
1508 register CORE_ADDR pc
;
1509 register struct minimal_symbol
*msymbol
;
1511 struct symbol
*sym_class
;
1514 struct symbol
**sym_arr
;
1516 char *saved_arg
= *argptr
;
1517 extern char *gdb_completer_quote_characters
;
1519 /* Defaults have defaults. */
1521 if (default_symtab
== 0)
1523 default_symtab
= current_source_symtab
;
1524 default_line
= current_source_line
;
1527 /* See if arg is *PC */
1529 if (**argptr
== '*')
1531 if (**argptr
== '*')
1535 pc
= parse_and_eval_address_1 (argptr
);
1536 values
.sals
= (struct symtab_and_line
*)
1537 xmalloc (sizeof (struct symtab_and_line
));
1539 values
.sals
[0] = find_pc_line (pc
, 0);
1540 values
.sals
[0].pc
= pc
;
1544 /* Maybe arg is FILE : LINENUM or FILE : FUNCTION */
1547 is_quoted
= (strchr (gdb_completer_quote_characters
, **argptr
) != NULL
);
1549 for (p
= *argptr
; *p
; p
++)
1551 if (p
[0] == ':' || p
[0] == ' ' || p
[0] == '\t')
1554 while (p
[0] == ' ' || p
[0] == '\t') p
++;
1556 if ((p
[0] == ':') && !is_quoted
)
1562 /* Extract the class name. */
1564 while (p
!= *argptr
&& p
[-1] == ' ') --p
;
1565 copy
= (char *) alloca (p
- *argptr
+ 1);
1566 memcpy (copy
, *argptr
, p
- *argptr
);
1567 copy
[p
- *argptr
] = 0;
1569 /* Discard the class name from the arg. */
1571 while (*p
== ' ' || *p
== '\t') p
++;
1574 sym_class
= lookup_symbol (copy
, 0, STRUCT_NAMESPACE
, 0,
1575 (struct symtab
**)NULL
);
1578 ( TYPE_CODE (SYMBOL_TYPE (sym_class
)) == TYPE_CODE_STRUCT
1579 || TYPE_CODE (SYMBOL_TYPE (sym_class
)) == TYPE_CODE_UNION
))
1581 /* Arg token is not digits => try it as a function name
1582 Find the next token (everything up to end or next whitespace). */
1584 while (*p
&& *p
!= ' ' && *p
!= '\t' && *p
!= ',' && *p
!=':') p
++;
1585 q
= operator_chars (*argptr
, &q1
);
1590 char *tmp
= alloca (q1
- q
+ 1);
1591 memcpy (tmp
, q
, q1
- q
);
1593 opname
= cplus_mangle_opname (tmp
, DMGL_ANSI
);
1596 warning ("no mangling for \"%s\"", tmp
);
1597 cplusplus_hint (saved_arg
);
1598 return_to_top_level (RETURN_ERROR
);
1600 copy
= (char*) alloca (3 + strlen(opname
));
1601 sprintf (copy
, "__%s", opname
);
1606 copy
= (char *) alloca (p
- *argptr
+ 1 + (q1
- q
));
1607 memcpy (copy
, *argptr
, p
- *argptr
);
1608 copy
[p
- *argptr
] = '\0';
1611 /* no line number may be specified */
1612 while (*p
== ' ' || *p
== '\t') p
++;
1616 i1
= 0; /* counter for the symbol array */
1617 t
= SYMBOL_TYPE (sym_class
);
1618 sym_arr
= (struct symbol
**) alloca(TYPE_NFN_FIELDS_TOTAL (t
) * sizeof(struct symbol
*));
1620 if (destructor_name_p (copy
, t
))
1622 /* destructors are a special case. */
1623 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, 0);
1624 int len
= TYPE_FN_FIELDLIST_LENGTH (t
, 0) - 1;
1625 /* gcc 1.x puts destructor in last field,
1626 gcc 2.x puts destructor in first field. */
1627 char *phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, len
);
1628 if (!DESTRUCTOR_PREFIX_P (phys_name
))
1630 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, 0);
1631 if (!DESTRUCTOR_PREFIX_P (phys_name
))
1635 lookup_symbol (phys_name
, SYMBOL_BLOCK_VALUE (sym_class
),
1636 VAR_NAMESPACE
, 0, (struct symtab
**)NULL
);
1637 if (sym_arr
[i1
]) i1
++;
1640 i1
= find_methods (t
, copy
, sym_arr
);
1643 /* There is exactly one field with that name. */
1646 if (sym
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
)
1648 /* Arg is the name of a function */
1649 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) + FUNCTION_START_OFFSET
;
1652 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
1654 values
.sals
[0] = find_pc_line (pc
, 0);
1655 values
.sals
[0].pc
= (values
.sals
[0].end
&& values
.sals
[0].pc
!= pc
) ? values
.sals
[0].end
: pc
;
1665 /* There is more than one field with that name
1666 (overloaded). Ask the user which one to use. */
1667 return decode_line_2 (sym_arr
, i1
, funfirstline
);
1673 if (OPNAME_PREFIX_P (copy
))
1675 tmp
= (char *)alloca (strlen (copy
+3) + 9);
1676 strcpy (tmp
, "operator ");
1677 strcat (tmp
, copy
+3);
1682 warning ("the class `%s' does not have destructor defined",
1683 SYMBOL_SOURCE_NAME(sym_class
));
1685 warning ("the class %s does not have any method named %s",
1686 SYMBOL_SOURCE_NAME(sym_class
), tmp
);
1687 cplusplus_hint (saved_arg
);
1688 return_to_top_level (RETURN_ERROR
);
1693 /* The quotes are important if copy is empty. */
1694 warning ("can't find class, struct, or union named \"%s\"",
1696 cplusplus_hint (saved_arg
);
1697 return_to_top_level (RETURN_ERROR
);
1703 /* Extract the file name. */
1705 while (p
!= *argptr
&& p
[-1] == ' ') --p
;
1706 copy
= (char *) alloca (p
- *argptr
+ 1);
1707 memcpy (copy
, *argptr
, p
- *argptr
);
1708 copy
[p
- *argptr
] = 0;
1710 /* Find that file's data. */
1711 s
= lookup_symtab (copy
);
1714 if (!have_full_symbols () && !have_partial_symbols ())
1715 error (no_symtab_msg
);
1716 error ("No source file named %s.", copy
);
1719 /* Discard the file name from the arg. */
1721 while (*p
== ' ' || *p
== '\t') p
++;
1725 /* S is specified file's symtab, or 0 if no file specified.
1726 arg no longer contains the file name. */
1728 /* Check whether arg is all digits (and sign) */
1731 if (*p
== '-' || *p
== '+') p
++;
1732 while (*p
>= '0' && *p
<= '9')
1735 if (p
!= *argptr
&& (*p
== 0 || *p
== ' ' || *p
== '\t' || *p
== ','))
1737 /* We found a token consisting of all digits -- at least one digit. */
1738 enum sign
{none
, plus
, minus
} sign
= none
;
1740 /* This is where we need to make sure that we have good defaults.
1741 We must guarantee that this section of code is never executed
1742 when we are called with just a function name, since
1743 select_source_symtab calls us with such an argument */
1745 if (s
== 0 && default_symtab
== 0)
1747 select_source_symtab (0);
1748 default_symtab
= current_source_symtab
;
1749 default_line
= current_source_line
;
1752 if (**argptr
== '+')
1753 sign
= plus
, (*argptr
)++;
1754 else if (**argptr
== '-')
1755 sign
= minus
, (*argptr
)++;
1756 val
.line
= atoi (*argptr
);
1763 val
.line
= default_line
+ val
.line
;
1769 val
.line
= default_line
- val
.line
;
1774 break; /* No need to adjust val.line. */
1777 while (*p
== ' ' || *p
== '\t') p
++;
1783 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
1784 values
.sals
[0] = val
;
1789 /* Arg token is not digits => try it as a variable name
1790 Find the next token (everything up to end or next whitespace). */
1792 p
= skip_quoted (*argptr
);
1793 copy
= (char *) alloca (p
- *argptr
+ 1);
1794 memcpy (copy
, *argptr
, p
- *argptr
);
1795 copy
[p
- *argptr
] = '\0';
1796 if ((copy
[0] == copy
[p
- *argptr
- 1])
1797 && strchr (gdb_completer_quote_characters
, copy
[0]) != NULL
)
1800 copy
[p
- *argptr
- 1] = '\0';
1803 while (*p
== ' ' || *p
== '\t') p
++;
1806 /* Look up that token as a variable.
1807 If file specified, use that file's per-file block to start with. */
1809 sym
= lookup_symbol (copy
,
1810 (s
? BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)
1811 : get_selected_block ()),
1812 VAR_NAMESPACE
, 0, &sym_symtab
);
1816 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
1818 /* Arg is the name of a function */
1819 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) + FUNCTION_START_OFFSET
;
1822 val
= find_pc_line (pc
, 0);
1823 #ifdef PROLOGUE_FIRSTLINE_OVERLAP
1824 /* Convex: no need to suppress code on first line, if any */
1827 /* Check if SKIP_PROLOGUE left us in mid-line, and the next
1828 line is still part of the same function. */
1830 && BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) <= val
.end
1831 && val
.end
< BLOCK_END (SYMBOL_BLOCK_VALUE (sym
)))
1833 /* First pc of next line */
1835 /* Recalculate the line number (might not be N+1). */
1836 val
= find_pc_line (pc
, 0);
1840 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
1841 values
.sals
[0] = val
;
1844 /* I think this is always the same as the line that
1845 we calculate above, but the general principle is
1846 "trust the symbols more than stuff like
1848 if (SYMBOL_LINE (sym
) != 0)
1849 values
.sals
[0].line
= SYMBOL_LINE (sym
);
1853 else if (SYMBOL_LINE (sym
) != 0)
1855 /* We know its line number. */
1856 values
.sals
= (struct symtab_and_line
*)
1857 xmalloc (sizeof (struct symtab_and_line
));
1859 memset (&values
.sals
[0], 0, sizeof (values
.sals
[0]));
1860 values
.sals
[0].symtab
= sym_symtab
;
1861 values
.sals
[0].line
= SYMBOL_LINE (sym
);
1865 /* This can happen if it is compiled with a compiler which doesn't
1866 put out line numbers for variables. */
1867 /* FIXME: Shouldn't we just set .line and .symtab to zero and
1868 return? For example, "info line foo" could print the address. */
1869 error ("Line number not known for symbol \"%s\"", copy
);
1872 msymbol
= lookup_minimal_symbol (copy
, (struct objfile
*) NULL
);
1873 if (msymbol
!= NULL
)
1877 val
.pc
= SYMBOL_VALUE_ADDRESS (msymbol
) + FUNCTION_START_OFFSET
;
1879 SKIP_PROLOGUE (val
.pc
);
1880 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
1881 values
.sals
[0] = val
;
1886 if (!have_full_symbols () &&
1887 !have_partial_symbols () && !have_minimal_symbols ())
1888 error (no_symtab_msg
);
1890 error ("Function \"%s\" not defined.", copy
);
1891 return values
; /* for lint */
1894 struct symtabs_and_lines
1895 decode_line_spec (string
, funfirstline
)
1899 struct symtabs_and_lines sals
;
1901 error ("Empty line specification.");
1902 sals
= decode_line_1 (&string
, funfirstline
,
1903 current_source_symtab
, current_source_line
);
1905 error ("Junk at end of line specification: %s", string
);
1909 /* Given a list of NELTS symbols in sym_arr, return a list of lines to
1910 operate on (ask user if necessary). */
1912 static struct symtabs_and_lines
1913 decode_line_2 (sym_arr
, nelts
, funfirstline
)
1914 struct symbol
*sym_arr
[];
1918 struct symtabs_and_lines values
, return_values
;
1919 register CORE_ADDR pc
;
1925 values
.sals
= (struct symtab_and_line
*) alloca (nelts
* sizeof(struct symtab_and_line
));
1926 return_values
.sals
= (struct symtab_and_line
*) xmalloc (nelts
* sizeof(struct symtab_and_line
));
1929 printf("[0] cancel\n[1] all\n");
1932 if (sym_arr
[i
] && SYMBOL_CLASS (sym_arr
[i
]) == LOC_BLOCK
)
1934 /* Arg is the name of a function */
1935 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym_arr
[i
]))
1936 + FUNCTION_START_OFFSET
;
1939 values
.sals
[i
] = find_pc_line (pc
, 0);
1940 values
.sals
[i
].pc
= (values
.sals
[i
].end
&& values
.sals
[i
].pc
!= pc
) ?
1941 values
.sals
[i
].end
: pc
;
1942 printf("[%d] %s at %s:%d\n", (i
+2), SYMBOL_SOURCE_NAME (sym_arr
[i
]),
1943 values
.sals
[i
].symtab
->filename
, values
.sals
[i
].line
);
1945 else printf ("?HERE\n");
1949 if ((prompt
= getenv ("PS2")) == NULL
)
1953 printf("%s ",prompt
);
1956 args
= command_line_input ((char *) NULL
, 0);
1959 error_no_arg ("one or more choice numbers");
1967 while (*arg1
>= '0' && *arg1
<= '9') arg1
++;
1968 if (*arg1
&& *arg1
!= ' ' && *arg1
!= '\t')
1969 error ("Arguments must be choice numbers.");
1974 error ("cancelled");
1977 memcpy (return_values
.sals
, values
.sals
,
1978 (nelts
* sizeof(struct symtab_and_line
)));
1979 return_values
.nelts
= nelts
;
1980 return return_values
;
1983 if (num
> nelts
+ 2)
1985 printf ("No choice number %d.\n", num
);
1990 if (values
.sals
[num
].pc
)
1992 return_values
.sals
[i
++] = values
.sals
[num
];
1993 values
.sals
[num
].pc
= 0;
1997 printf ("duplicate request for %d ignored.\n", num
);
2002 while (*args
== ' ' || *args
== '\t') args
++;
2004 return_values
.nelts
= i
;
2005 return return_values
;
2009 /* Slave routine for sources_info. Force line breaks at ,'s.
2010 NAME is the name to print and *FIRST is nonzero if this is the first
2011 name printed. Set *FIRST to zero. */
2013 output_source_filename (name
, first
)
2017 /* Table of files printed so far. Since a single source file can
2018 result in several partial symbol tables, we need to avoid printing
2019 it more than once. Note: if some of the psymtabs are read in and
2020 some are not, it gets printed both under "Source files for which
2021 symbols have been read" and "Source files for which symbols will
2022 be read in on demand". I consider this a reasonable way to deal
2023 with the situation. I'm not sure whether this can also happen for
2024 symtabs; it doesn't hurt to check. */
2025 static char **tab
= NULL
;
2026 /* Allocated size of tab in elements.
2027 Start with one 256-byte block (when using GNU malloc.c).
2028 24 is the malloc overhead when range checking is in effect. */
2029 static int tab_alloc_size
= (256 - 24) / sizeof (char *);
2030 /* Current size of tab in elements. */
2031 static int tab_cur_size
;
2038 tab
= (char **) xmalloc (tab_alloc_size
* sizeof (*tab
));
2042 /* Is NAME in tab? */
2043 for (p
= tab
; p
< tab
+ tab_cur_size
; p
++)
2044 if (STREQ (*p
, name
))
2045 /* Yes; don't print it again. */
2047 /* No; add it to tab. */
2048 if (tab_cur_size
== tab_alloc_size
)
2050 tab_alloc_size
*= 2;
2051 tab
= (char **) xrealloc ((char *) tab
, tab_alloc_size
* sizeof (*tab
));
2053 tab
[tab_cur_size
++] = name
;
2061 printf_filtered (", ");
2065 fputs_filtered (name
, stdout
);
2069 sources_info (ignore
, from_tty
)
2073 register struct symtab
*s
;
2074 register struct partial_symtab
*ps
;
2075 register struct objfile
*objfile
;
2078 if (!have_full_symbols () && !have_partial_symbols ())
2080 error (no_symtab_msg
);
2083 printf_filtered ("Source files for which symbols have been read in:\n\n");
2086 ALL_SYMTABS (objfile
, s
)
2088 output_source_filename (s
-> filename
, &first
);
2090 printf_filtered ("\n\n");
2092 printf_filtered ("Source files for which symbols will be read in on demand:\n\n");
2095 ALL_PSYMTABS (objfile
, ps
)
2099 output_source_filename (ps
-> filename
, &first
);
2102 printf_filtered ("\n");
2105 /* List all symbols (if REGEXP is NULL) or all symbols matching REGEXP.
2106 If CLASS is zero, list all symbols except functions, type names, and
2108 If CLASS is 1, list only functions.
2109 If CLASS is 2, list only type names.
2110 If CLASS is 3, list only method names.
2112 BPT is non-zero if we should set a breakpoint at the functions
2116 list_symbols (regexp
, class, bpt
)
2121 register struct symtab
*s
;
2122 register struct partial_symtab
*ps
;
2123 register struct blockvector
*bv
;
2124 struct blockvector
*prev_bv
= 0;
2125 register struct block
*b
;
2127 register struct symbol
*sym
;
2128 struct partial_symbol
*psym
;
2129 struct objfile
*objfile
;
2130 struct minimal_symbol
*msymbol
;
2132 static char *classnames
[]
2133 = {"variable", "function", "type", "method"};
2134 int found_in_file
= 0;
2136 static enum minimal_symbol_type types
[]
2137 = {mst_data
, mst_text
, mst_abs
, mst_unknown
};
2138 static enum minimal_symbol_type types2
[]
2139 = {mst_bss
, mst_text
, mst_abs
, mst_unknown
};
2140 enum minimal_symbol_type ourtype
= types
[class];
2141 enum minimal_symbol_type ourtype2
= types2
[class];
2145 /* Make sure spacing is right for C++ operators.
2146 This is just a courtesy to make the matching less sensitive
2147 to how many spaces the user leaves between 'operator'
2148 and <TYPENAME> or <OPERATOR>. */
2150 char *opname
= operator_chars (regexp
, &opend
);
2153 int fix
= -1; /* -1 means ok; otherwise number of spaces needed. */
2154 if (isalpha(*opname
) || *opname
== '_' || *opname
== '$')
2156 /* There should 1 space between 'operator' and 'TYPENAME'. */
2157 if (opname
[-1] != ' ' || opname
[-2] == ' ')
2162 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
2163 if (opname
[-1] == ' ')
2166 /* If wrong number of spaces, fix it. */
2169 char *tmp
= (char*) alloca(opend
-opname
+10);
2170 sprintf(tmp
, "operator%.*s%s", fix
, " ", opname
);
2175 if (0 != (val
= re_comp (regexp
)))
2176 error ("Invalid regexp (%s): %s", val
, regexp
);
2179 /* Search through the partial symtabs *first* for all symbols
2180 matching the regexp. That way we don't have to reproduce all of
2181 the machinery below. */
2183 ALL_PSYMTABS (objfile
, ps
)
2185 struct partial_symbol
*bound
, *gbound
, *sbound
;
2188 if (ps
->readin
) continue;
2190 gbound
= objfile
->global_psymbols
.list
+ ps
->globals_offset
+ ps
->n_global_syms
;
2191 sbound
= objfile
->static_psymbols
.list
+ ps
->statics_offset
+ ps
->n_static_syms
;
2194 /* Go through all of the symbols stored in a partial
2195 symtab in one loop. */
2196 psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
2201 if (bound
== gbound
&& ps
->n_static_syms
!= 0)
2203 psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
2214 /* If it would match (logic taken from loop below)
2215 load the file and go on to the next one */
2216 if ((regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (psym
))
2217 && ((class == 0 && SYMBOL_CLASS (psym
) != LOC_TYPEDEF
2218 && SYMBOL_CLASS (psym
) != LOC_BLOCK
)
2219 || (class == 1 && SYMBOL_CLASS (psym
) == LOC_BLOCK
)
2220 || (class == 2 && SYMBOL_CLASS (psym
) == LOC_TYPEDEF
)
2221 || (class == 3 && SYMBOL_CLASS (psym
) == LOC_BLOCK
)))
2223 PSYMTAB_TO_SYMTAB(ps
);
2231 /* Here, we search through the minimal symbol tables for functions that
2232 match, and call find_pc_symtab on them to force their symbols to
2233 be read. The symbol will then be found during the scan of symtabs
2234 below. If find_pc_symtab fails, set found_misc so that we will
2235 rescan to print any matching symbols without debug info. */
2239 ALL_MSYMBOLS (objfile
, msymbol
)
2241 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
2242 MSYMBOL_TYPE (msymbol
) == ourtype2
)
2244 if (regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (msymbol
))
2246 if (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
)))
2255 /* Printout here so as to get after the "Reading in symbols"
2256 messages which will be generated above. */
2258 printf_filtered (regexp
2259 ? "All %ss matching regular expression \"%s\":\n"
2260 : "All defined %ss:\n",
2264 ALL_SYMTABS (objfile
, s
)
2267 bv
= BLOCKVECTOR (s
);
2268 /* Often many files share a blockvector.
2269 Scan each blockvector only once so that
2270 we don't get every symbol many times.
2271 It happens that the first symtab in the list
2272 for any given blockvector is the main file. */
2274 for (i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; i
++)
2276 b
= BLOCKVECTOR_BLOCK (bv
, i
);
2277 /* Skip the sort if this block is always sorted. */
2278 if (!BLOCK_SHOULD_SORT (b
))
2279 sort_block_syms (b
);
2280 for (j
= 0; j
< BLOCK_NSYMS (b
); j
++)
2283 sym
= BLOCK_SYM (b
, j
);
2284 if ((regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (sym
))
2285 && ((class == 0 && SYMBOL_CLASS (sym
) != LOC_TYPEDEF
2286 && SYMBOL_CLASS (sym
) != LOC_BLOCK
2287 && SYMBOL_CLASS (sym
) != LOC_CONST
)
2288 || (class == 1 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2289 || (class == 2 && SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
2290 || (class == 3 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)))
2294 /* Set a breakpoint here, if it's a function */
2297 /* There may be more than one function with the
2298 same name but in different files. In order to
2299 set breakpoints on all of them, we must give
2300 both the file name and the function name to
2303 (char *) alloca (strlen (s
->filename
)
2304 + strlen (SYMBOL_NAME(sym
))
2306 strcpy (string
, s
->filename
);
2307 strcat (string
, ":");
2308 strcat (string
, SYMBOL_NAME(sym
));
2309 break_command (string
, 0);
2312 else if (!found_in_file
)
2314 fputs_filtered ("\nFile ", stdout
);
2315 fputs_filtered (s
->filename
, stdout
);
2316 fputs_filtered (":\n", stdout
);
2320 if (class != 2 && i
== STATIC_BLOCK
)
2321 printf_filtered ("static ");
2323 /* Typedef that is not a C++ class */
2325 && SYMBOL_NAMESPACE (sym
) != STRUCT_NAMESPACE
)
2326 c_typedef_print (SYMBOL_TYPE(sym
), sym
, stdout
);
2327 /* variable, func, or typedef-that-is-c++-class */
2328 else if (class < 2 ||
2330 SYMBOL_NAMESPACE(sym
) == STRUCT_NAMESPACE
))
2332 type_print (SYMBOL_TYPE (sym
),
2333 (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
2334 ? "" : SYMBOL_SOURCE_NAME (sym
)),
2337 printf_filtered (";\n");
2341 # if 0 /* FIXME, why is this zapped out? */
2343 c_type_print_base (TYPE_FN_FIELD_TYPE(t
, i
),
2345 c_type_print_varspec_prefix (TYPE_FN_FIELD_TYPE(t
, i
),
2347 sprintf (buf
, " %s::", type_name_no_tag (t
));
2348 cp_type_print_method_args (TYPE_FN_FIELD_ARGS (t
, i
),
2358 /* If there are no eyes, avoid all contact. I mean, if there are
2359 no debug symbols, then print directly from the msymbol_vector. */
2361 if (found_misc
|| class != 1)
2364 ALL_MSYMBOLS (objfile
, msymbol
)
2366 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
2367 MSYMBOL_TYPE (msymbol
) == ourtype2
)
2369 if (regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (msymbol
))
2371 /* Functions: Look up by address. */
2373 (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
))))
2375 /* Variables/Absolutes: Look up by name */
2376 if (lookup_symbol (SYMBOL_NAME (msymbol
),
2377 (struct block
*) NULL
, VAR_NAMESPACE
,
2378 0, (struct symtab
**) NULL
) == NULL
)
2382 printf_filtered ("\nNon-debugging symbols:\n");
2385 printf_filtered (" %08x %s\n",
2386 SYMBOL_VALUE_ADDRESS (msymbol
),
2387 SYMBOL_SOURCE_NAME (msymbol
));
2397 variables_info (regexp
, from_tty
)
2401 list_symbols (regexp
, 0, 0);
2405 functions_info (regexp
, from_tty
)
2409 list_symbols (regexp
, 1, 0);
2413 types_info (regexp
, from_tty
)
2417 list_symbols (regexp
, 2, 0);
2421 /* Tiemann says: "info methods was never implemented." */
2423 methods_info (regexp
)
2426 list_symbols (regexp
, 3, 0);
2430 /* Breakpoint all functions matching regular expression. */
2432 rbreak_command (regexp
, from_tty
)
2436 list_symbols (regexp
, 1, 1);
2440 /* Return Nonzero if block a is lexically nested within block b,
2441 or if a and b have the same pc range.
2442 Return zero otherwise. */
2445 struct block
*a
, *b
;
2449 return BLOCK_START (a
) >= BLOCK_START (b
)
2450 && BLOCK_END (a
) <= BLOCK_END (b
);
2454 /* Helper routine for make_symbol_completion_list. */
2456 static int return_val_size
;
2457 static int return_val_index
;
2458 static char **return_val
;
2460 #define COMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
2462 completion_list_add_name (SYMBOL_NAME (symbol), (sym_text), (len), \
2464 if (SYMBOL_DEMANGLED_NAME (symbol) != NULL) \
2465 completion_list_add_name \
2466 (SYMBOL_DEMANGLED_NAME (symbol), (sym_text), (len), (text), (word)); \
2469 /* Test to see if the symbol specified by SYMNAME (which is already
2470 demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
2471 characters. If so, add it to the current completion list. */
2474 completion_list_add_name (symname
, sym_text
, sym_text_len
, text
, word
)
2484 /* clip symbols that cannot match */
2486 if (strncmp (symname
, sym_text
, sym_text_len
) != 0)
2491 /* Clip any symbol names that we've already considered. (This is a
2492 time optimization) */
2494 for (i
= 0; i
< return_val_index
; ++i
)
2496 if (STREQ (symname
, return_val
[i
]))
2502 /* We have a match for a completion, so add SYMNAME to the current list
2503 of matches. Note that the name is moved to freshly malloc'd space. */
2507 if (word
== sym_text
)
2509 new = xmalloc (strlen (symname
) + 5);
2510 strcpy (new, symname
);
2512 else if (word
> sym_text
)
2514 /* Return some portion of symname. */
2515 new = xmalloc (strlen (symname
) + 5);
2516 strcpy (new, symname
+ (word
- sym_text
));
2520 /* Return some of SYM_TEXT plus symname. */
2521 new = xmalloc (strlen (symname
) + (sym_text
- word
) + 5);
2522 strncpy (new, word
, sym_text
- word
);
2523 new[sym_text
- word
] = '\0';
2524 strcat (new, symname
);
2527 if (return_val_index
+ 3 > return_val_size
)
2529 newsize
= (return_val_size
*= 2) * sizeof (char *);
2530 return_val
= (char **) xrealloc ((char *) return_val
, newsize
);
2532 return_val
[return_val_index
++] = new;
2533 return_val
[return_val_index
] = NULL
;
2537 /* Return a NULL terminated array of all symbols (regardless of class) which
2538 begin by matching TEXT. If the answer is no symbols, then the return value
2539 is an array which contains only a NULL pointer.
2541 Problem: All of the symbols have to be copied because readline frees them.
2542 I'm not going to worry about this; hopefully there won't be that many. */
2545 make_symbol_completion_list (text
, word
)
2549 register struct symbol
*sym
;
2550 register struct symtab
*s
;
2551 register struct partial_symtab
*ps
;
2552 register struct minimal_symbol
*msymbol
;
2553 register struct objfile
*objfile
;
2554 register struct block
*b
, *surrounding_static_block
= 0;
2556 struct partial_symbol
*psym
;
2557 /* The symbol we are completing on. Points in same buffer as text. */
2559 /* Length of sym_text. */
2562 /* Now look for the symbol we are supposed to complete on.
2563 FIXME: This should be language-specific. */
2569 /* First see if this is a quoted string. */
2571 for (p
= text
; *p
!= '\0'; ++p
)
2573 if (quote_found
!= '\0')
2575 if (*p
== quote_found
)
2576 /* Found close quote. */
2578 else if (*p
== '\\' && p
[1] == quote_found
)
2579 /* A backslash followed by the quote character
2580 doesn't end the string. */
2583 else if (*p
== '\'' || *p
== '"')
2589 if (quote_found
== '\'')
2590 /* A string within single quotes can be a symbol, so complete on it. */
2591 sym_text
= quote_pos
+ 1;
2592 else if (quote_found
== '"')
2593 /* A double-quoted string is never a symbol, nor does it make sense
2594 to complete it any other way. */
2598 /* It is not a quoted string. Break it based on the characters
2599 which are in symbols. */
2602 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0')
2611 sym_text_len
= strlen (sym_text
);
2613 return_val_size
= 100;
2614 return_val_index
= 0;
2615 return_val
= (char **) xmalloc ((return_val_size
+ 1) * sizeof (char *));
2616 return_val
[0] = NULL
;
2618 /* Look through the partial symtabs for all symbols which begin
2619 by matching SYM_TEXT. Add each one that you find to the list. */
2621 ALL_PSYMTABS (objfile
, ps
)
2623 /* If the psymtab's been read in we'll get it when we search
2624 through the blockvector. */
2625 if (ps
->readin
) continue;
2627 for (psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
2628 psym
< (objfile
->global_psymbols
.list
+ ps
->globals_offset
2629 + ps
->n_global_syms
);
2632 /* If interrupted, then quit. */
2634 COMPLETION_LIST_ADD_SYMBOL (psym
, sym_text
, sym_text_len
, text
, word
);
2637 for (psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
2638 psym
< (objfile
->static_psymbols
.list
+ ps
->statics_offset
2639 + ps
->n_static_syms
);
2643 COMPLETION_LIST_ADD_SYMBOL (psym
, sym_text
, sym_text_len
, text
, word
);
2647 /* At this point scan through the misc symbol vectors and add each
2648 symbol you find to the list. Eventually we want to ignore
2649 anything that isn't a text symbol (everything else will be
2650 handled by the psymtab code above). */
2652 ALL_MSYMBOLS (objfile
, msymbol
)
2655 COMPLETION_LIST_ADD_SYMBOL (msymbol
, sym_text
, sym_text_len
, text
, word
);
2658 /* Search upwards from currently selected frame (so that we can
2659 complete on local vars. */
2661 for (b
= get_selected_block (); b
!= NULL
; b
= BLOCK_SUPERBLOCK (b
))
2663 if (!BLOCK_SUPERBLOCK (b
))
2665 surrounding_static_block
= b
; /* For elmin of dups */
2668 /* Also catch fields of types defined in this places which match our
2669 text string. Only complete on types visible from current context. */
2671 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2673 sym
= BLOCK_SYM (b
, i
);
2674 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
2675 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
2677 struct type
*t
= SYMBOL_TYPE (sym
);
2678 enum type_code c
= TYPE_CODE (t
);
2680 if (c
== TYPE_CODE_UNION
|| c
== TYPE_CODE_STRUCT
)
2682 for (j
= TYPE_N_BASECLASSES (t
); j
< TYPE_NFIELDS (t
); j
++)
2684 if (TYPE_FIELD_NAME (t
, j
))
2686 completion_list_add_name (TYPE_FIELD_NAME (t
, j
),
2687 sym_text
, sym_text_len
, text
, word
);
2695 /* Go through the symtabs and check the externs and statics for
2696 symbols which match. */
2698 ALL_SYMTABS (objfile
, s
)
2701 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
2702 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2704 sym
= BLOCK_SYM (b
, i
);
2705 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
2709 ALL_SYMTABS (objfile
, s
)
2712 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
2713 /* Don't do this block twice. */
2714 if (b
== surrounding_static_block
) continue;
2715 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2717 sym
= BLOCK_SYM (b
, i
);
2718 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
2722 return (return_val
);
2727 /* Add the type of the symbol sym to the type of the current
2728 function whose block we are in (assumed). The type of
2729 this current function is contained in *TYPE.
2731 This basically works as follows: When we find a function
2732 symbol (N_FUNC with a 'f' or 'F' in the symbol name), we record
2733 a pointer to its type in the global in_function_type. Every
2734 time we come across a parameter symbol ('p' in its name), then
2735 this procedure adds the name and type of that parameter
2736 to the function type pointed to by *TYPE. (Which should correspond
2737 to in_function_type if it was called correctly).
2739 Note that since we are modifying a type, the result of
2740 lookup_function_type() should be memcpy()ed before calling
2741 this. When not in strict typing mode, the expression
2742 evaluator can choose to ignore this.
2744 Assumption: All of a function's parameter symbols will
2745 appear before another function symbol is found. The parameters
2746 appear in the same order in the argument list as they do in the
2750 add_param_to_type (type
,sym
)
2754 int num
= ++(TYPE_NFIELDS(*type
));
2756 if(TYPE_NFIELDS(*type
)-1)
2757 TYPE_FIELDS(*type
) = (struct field
*)
2758 (*current_objfile
->xrealloc
) ((char *)(TYPE_FIELDS(*type
)),
2759 num
*sizeof(struct field
));
2761 TYPE_FIELDS(*type
) = (struct field
*)
2762 (*current_objfile
->xmalloc
) (num
*sizeof(struct field
));
2764 TYPE_FIELD_BITPOS(*type
,num
-1) = num
-1;
2765 TYPE_FIELD_BITSIZE(*type
,num
-1) = 0;
2766 TYPE_FIELD_TYPE(*type
,num
-1) = SYMBOL_TYPE(sym
);
2767 TYPE_FIELD_NAME(*type
,num
-1) = SYMBOL_NAME(sym
);
2772 _initialize_symtab ()
2774 add_info ("variables", variables_info
,
2775 "All global and static variable names, or those matching REGEXP.");
2776 add_info ("functions", functions_info
,
2777 "All function names, or those matching REGEXP.");
2779 /* FIXME: This command has at least the following problems:
2780 1. It prints builtin types (in a very strange and confusing fashion).
2781 2. It doesn't print right, e.g. with
2782 typedef struct foo *FOO
2783 type_print prints "FOO" when we want to make it (in this situation)
2784 print "struct foo *".
2785 I also think "ptype" or "whatis" is more likely to be useful (but if
2786 there is much disagreement "info types" can be fixed). */
2787 add_info ("types", types_info
,
2788 "All type names, or those matching REGEXP.");
2791 add_info ("methods", methods_info
,
2792 "All method names, or those matching REGEXP::REGEXP.\n\
2793 If the class qualifier is omitted, it is assumed to be the current scope.\n\
2794 If the first REGEXP is omitted, then all methods matching the second REGEXP\n\
2797 add_info ("sources", sources_info
,
2798 "Source files in the program.");
2800 add_com ("rbreak", no_class
, rbreak_command
,
2801 "Set a breakpoint for all functions matching REGEXP.");
2803 /* Initialize the one built-in type that isn't language dependent... */
2804 builtin_type_error
= init_type (TYPE_CODE_ERROR
, 0, 0,
2805 "<unknown type>", (struct objfile
*) NULL
);