1 /* Symbol table lookup for the GNU debugger, GDB.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
35 #include <sys/types.h>
40 extern char *getenv ();
42 extern char *cplus_demangle ();
43 extern char *cplus_mangle_opname ();
44 extern struct value
*value_of_this ();
45 extern void break_command ();
46 extern void select_source_symtab ();
48 /* Functions this file defines */
49 static int find_line_common ();
50 struct partial_symtab
*lookup_partial_symtab ();
51 static struct partial_symbol
*lookup_partial_symbol ();
52 static struct partial_symbol
*lookup_demangled_partial_symbol ();
53 static struct symbol
*lookup_demangled_block_symbol ();
55 /* The single non-language-specific builtin type */
56 struct type
*builtin_type_error
;
58 /* Block in which the most recently searched-for symbol was found.
59 Might be better to make this a parameter to lookup_symbol and
61 struct block
*block_found
;
63 char no_symtab_msg
[] = "No symbol table is loaded. Use the \"file\" command.";
65 /* Check for a symtab of a specific name; first in symtabs, then in
66 psymtabs. *If* there is no '/' in the name, a match after a '/'
67 in the symtab filename will also work. */
69 static struct symtab
*
70 lookup_symtab_1 (name
)
73 register struct symtab
*s
;
74 register struct partial_symtab
*ps
;
75 register char *slash
= strchr (name
, '/');
76 register int len
= strlen (name
);
78 for (s
= symtab_list
; s
; s
= s
->next
)
79 if (!strcmp (name
, s
->filename
))
82 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
83 if (!strcmp (name
, ps
->filename
))
86 error ("Internal: readin pst for `%s' found when no symtab found.", name
);
87 return PSYMTAB_TO_SYMTAB (ps
);
92 for (s
= symtab_list
; s
; s
= s
->next
)
94 int l
= strlen (s
->filename
);
96 if (s
->filename
[l
- len
-1] == '/'
97 && !strcmp (s
->filename
+ l
- len
, name
))
101 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
103 int l
= strlen (ps
->filename
);
105 if (ps
->filename
[l
- len
- 1] == '/'
106 && !strcmp (ps
->filename
+ l
- len
, name
))
109 error ("Internal: readin pst for `%s' found when no symtab found.", name
);
110 return PSYMTAB_TO_SYMTAB (ps
);
117 /* Lookup the symbol table of a source file named NAME. Try a couple
118 of variations if the first lookup doesn't work. */
124 register struct symtab
*s
;
127 s
= lookup_symtab_1 (name
);
130 /* If name not found as specified, see if adding ".c" helps. */
132 copy
= (char *) alloca (strlen (name
) + 3);
135 s
= lookup_symtab_1 (copy
);
138 /* We didn't find anything; die. */
142 /* Lookup the partial symbol table of a source file named NAME. This
143 only returns true on an exact match (ie. this semantics are
144 different from lookup_symtab. */
146 struct partial_symtab
*
147 lookup_partial_symtab (name
)
150 register struct partial_symtab
*s
;
152 for (s
= partial_symtab_list
; s
; s
= s
->next
)
153 if (!strcmp (name
, s
->filename
))
159 /* Return a typename for a struct/union/enum type
160 without the tag qualifier. If the type has a NULL name,
163 type_name_no_tag (type
)
164 register struct type
*type
;
166 register char *name
= TYPE_NAME (type
);
171 switch (TYPE_CODE (type
))
173 case TYPE_CODE_STRUCT
:
174 if(!strncmp(name
,"struct ",7))
177 case TYPE_CODE_UNION
:
178 if(!strncmp(name
,"union ",6))
182 if(!strncmp(name
,"enum ",5))
190 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
192 If this is a stubbed struct (i.e. declared as struct foo *), see if
193 we can find a full definition in some other file. If so, copy this
194 definition, so we can use it in future. If not, set a flag so we
195 don't waste too much time in future. (FIXME, this doesn't seem
198 This used to be coded as a macro, but I don't think it is called
199 often enough to merit such treatment.
202 struct complaint stub_noname_complaint
=
203 {"stub type has NULL name", 0, 0};
206 check_stub_type(type
)
209 if (TYPE_FLAGS(type
) & TYPE_FLAG_STUB
)
211 char* name
= type_name_no_tag (type
);
215 complain (&stub_noname_complaint
, 0);
218 sym
= lookup_symbol (name
, 0, STRUCT_NAMESPACE
, 0,
219 (struct symtab
**)NULL
);
221 bcopy (SYMBOL_TYPE(sym
), type
, sizeof (struct type
));
225 /* Demangle a GDB method stub type. */
227 gdb_mangle_name (type
, i
, j
)
231 int mangled_name_len
;
233 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
234 struct fn_field
*method
= &f
[j
];
235 char *field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
237 /* Need a new type prefix. */
239 char *const_prefix
= method
->is_const
? "C" : "";
240 char *volatile_prefix
= method
->is_volatile
? "V" : "";
241 char *newname
= type_name_no_tag (type
);
243 int len
= strlen (newname
);
245 sprintf (buf
, "__%s%s%d", const_prefix
, volatile_prefix
, len
);
246 mangled_name_len
= (strlen (field_name
)
248 + strlen (TYPE_FN_FIELD_PHYSNAME (f
, j
))
251 /* Only needed for GNU-mangled names. ANSI-mangled names
252 work with the normal mechanisms. */
253 if (OPNAME_PREFIX_P (field_name
))
255 char *opname
= cplus_mangle_opname (field_name
+ 3, 0);
257 error ("No mangling for \"%s\"", field_name
);
258 mangled_name_len
+= strlen (opname
);
259 mangled_name
= (char *)xmalloc (mangled_name_len
);
261 strncpy (mangled_name
, field_name
, 3);
262 mangled_name
[3] = '\0';
263 strcat (mangled_name
, opname
);
267 mangled_name
= (char *)xmalloc (mangled_name_len
);
268 strcpy (mangled_name
, TYPE_FN_FIELDLIST_NAME (type
, i
));
270 strcat (mangled_name
, buf
);
271 strcat (mangled_name
, newname
);
272 strcat (mangled_name
, TYPE_FN_FIELD_PHYSNAME (f
, j
));
277 /* Lookup a primitive type named NAME.
278 Return zero if NAME is not a primitive type.*/
281 lookup_primitive_typename (name
)
284 struct type
** const *p
;
286 for (p
= current_language
->la_builtin_type_vector
; *p
; p
++)
287 if(!strcmp((**p
)->name
, name
))
292 /* Lookup a typedef or primitive type named NAME,
293 visible in lexical block BLOCK.
294 If NOERR is nonzero, return zero if NAME is not suitably defined. */
297 lookup_typename (name
, block
, noerr
)
302 register struct symbol
*sym
=
303 lookup_symbol (name
, block
, VAR_NAMESPACE
, 0, (struct symtab
**)NULL
);
304 if (sym
== 0 || SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
307 tmp
= lookup_primitive_typename (name
);
310 else if (!tmp
&& noerr
)
313 error ("No type named %s.", name
);
315 return SYMBOL_TYPE (sym
);
319 lookup_unsigned_typename (name
)
322 char *uns
= alloca (strlen(name
) + 10);
324 strcpy (uns
, "unsigned ");
325 strcpy (uns
+9, name
);
326 return lookup_typename (uns
, (struct block
*)0, 0);
329 /* Lookup a structure type named "struct NAME",
330 visible in lexical block BLOCK. */
333 lookup_struct (name
, block
)
337 register struct symbol
*sym
338 = lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0, (struct symtab
**)NULL
);
341 error ("No struct type named %s.", name
);
342 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
343 error ("This context has class, union or enum %s, not a struct.", name
);
344 return SYMBOL_TYPE (sym
);
347 /* Lookup a union type named "union NAME",
348 visible in lexical block BLOCK. */
351 lookup_union (name
, block
)
355 register struct symbol
*sym
356 = lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0, (struct symtab
**)NULL
);
359 error ("No union type named %s.", name
);
360 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_UNION
)
361 error ("This context has class, struct or enum %s, not a union.", name
);
362 return SYMBOL_TYPE (sym
);
365 /* Lookup an enum type named "enum NAME",
366 visible in lexical block BLOCK. */
369 lookup_enum (name
, block
)
373 register struct symbol
*sym
374 = lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0, (struct symtab
**)NULL
);
376 error ("No enum type named %s.", name
);
377 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_ENUM
)
378 error ("This context has class, struct or union %s, not an enum.", name
);
379 return SYMBOL_TYPE (sym
);
382 /* Lookup a template type named "template NAME<TYPE>",
383 visible in lexical block BLOCK. */
386 lookup_template_type (name
, type
, block
)
392 char *nam
= (char*) alloca(strlen(name
) + strlen(type
->name
) + 4);
395 strcat(nam
, type
->name
);
396 strcat(nam
, " >"); /* FIXME, extra space still introduced in gcc? */
398 sym
= lookup_symbol (nam
, block
, VAR_NAMESPACE
, 0, (struct symtab
**)NULL
);
401 error ("No template type named %s.", name
);
402 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
403 error ("This context has class, union or enum %s, not a struct.", name
);
404 return SYMBOL_TYPE (sym
);
407 /* Given a type TYPE, lookup the type of the component of type named
409 If NOERR is nonzero, return zero if NAME is not suitably defined. */
412 lookup_struct_elt_type (type
, name
, noerr
)
419 if ( TYPE_CODE (type
) != TYPE_CODE_STRUCT
420 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
422 target_terminal_ours ();
424 fprintf (stderr
, "Type ");
425 type_print (type
, "", stderr
, -1);
426 error (" is not a structure or union type.");
429 check_stub_type (type
);
431 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
433 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
435 if (t_field_name
&& !strcmp (t_field_name
, name
))
436 return TYPE_FIELD_TYPE (type
, i
);
438 /* OK, it's not in this class. Recursively check the baseclasses. */
439 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
441 struct type
*t
= lookup_struct_elt_type (TYPE_BASECLASS (type
, i
),
450 target_terminal_ours ();
452 fprintf (stderr
, "Type ");
453 type_print (type
, "", stderr
, -1);
454 fprintf (stderr
, " has no component named ");
455 fputs_filtered (name
, stderr
);
457 return (struct type
*)-1; /* For lint */
460 /* Given a type TYPE, return a type of pointers to that type.
461 May need to construct such a type if this is the first use. */
464 lookup_pointer_type (type
)
467 register struct type
*ptype
= TYPE_POINTER_TYPE (type
);
468 if (ptype
) return ptype
;
470 /* This is the first time anyone wanted a pointer to a TYPE. */
471 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
472 ptype
= (struct type
*) xmalloc (sizeof (struct type
));
474 ptype
= (struct type
*) obstack_alloc (symbol_obstack
,
475 sizeof (struct type
));
477 bzero (ptype
, sizeof (struct type
));
478 TYPE_TARGET_TYPE (ptype
) = type
;
479 TYPE_POINTER_TYPE (type
) = ptype
;
480 /* New type is permanent if type pointed to is permanent. */
481 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
482 TYPE_FLAGS (ptype
) |= TYPE_FLAG_PERM
;
483 /* We assume the machine has only one representation for pointers! */
484 /* FIXME: This confuses host<->target data representations, and is a
485 poor assumption besides. */
486 TYPE_LENGTH (ptype
) = sizeof (char *);
487 TYPE_CODE (ptype
) = TYPE_CODE_PTR
;
492 lookup_reference_type (type
)
495 register struct type
*rtype
= TYPE_REFERENCE_TYPE (type
);
496 if (rtype
) return rtype
;
498 /* This is the first time anyone wanted a pointer to a TYPE. */
499 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
500 rtype
= (struct type
*) xmalloc (sizeof (struct type
));
502 rtype
= (struct type
*) obstack_alloc (symbol_obstack
,
503 sizeof (struct type
));
505 bzero (rtype
, sizeof (struct type
));
506 TYPE_TARGET_TYPE (rtype
) = type
;
507 TYPE_REFERENCE_TYPE (type
) = rtype
;
508 /* New type is permanent if type pointed to is permanent. */
509 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
510 TYPE_FLAGS (rtype
) |= TYPE_FLAG_PERM
;
511 /* We assume the machine has only one representation for pointers! */
512 TYPE_LENGTH (rtype
) = sizeof (char *);
513 TYPE_CODE (rtype
) = TYPE_CODE_REF
;
518 /* Implement direct support for MEMBER_TYPE in GNU C++.
519 May need to construct such a type if this is the first use.
520 The TYPE is the type of the member. The DOMAIN is the type
521 of the aggregate that the member belongs to. */
524 lookup_member_type (type
, domain
)
525 struct type
*type
, *domain
;
527 register struct type
*mtype
;
529 mtype
= (struct type
*) obstack_alloc (symbol_obstack
,
530 sizeof (struct type
));
531 smash_to_member_type (mtype
, domain
, type
);
535 /* Allocate a stub method whose return type is TYPE.
536 This apparently happens for speed of symbol reading, since parsing
537 out the arguments to the method is cpu-intensive, the way we are doing
538 it. So, we will fill in arguments later.
539 This always returns a fresh type. */
542 allocate_stub_method (type
)
545 struct type
*mtype
= (struct type
*) obstack_alloc (symbol_obstack
,
546 sizeof (struct type
));
547 bzero (mtype
, sizeof (struct type
));
548 TYPE_TARGET_TYPE (mtype
) = type
;
549 /* _DOMAIN_TYPE (mtype) = unknown yet */
550 /* _ARG_TYPES (mtype) = unknown yet */
551 TYPE_FLAGS (mtype
) = TYPE_FLAG_STUB
;
552 TYPE_CODE (mtype
) = TYPE_CODE_METHOD
;
553 TYPE_LENGTH (mtype
) = 1;
557 /* Ugly hack to convert method stubs into method types.
559 He ain't kiddin'. This demangles the name of the method into a string
560 including argument types, parses out each argument type, generates
561 a string casting a zero to that type, evaluates the string, and stuffs
562 the resulting type into an argtype vector!!! Then it knows the type
563 of the whole function (including argument types for overloading),
564 which info used to be in the stab's but was removed to hack back
565 the space required for them. */
567 check_stub_method (type
, i
, j
)
571 extern char *gdb_mangle_name (), *strchr ();
573 char *mangled_name
= gdb_mangle_name (type
, i
, j
);
574 char *demangled_name
= cplus_demangle (mangled_name
, 0);
575 char *argtypetext
, *p
;
576 int depth
= 0, argcount
= 1;
577 struct type
**argtypes
;
580 /* Now, read in the parameters that define this type. */
581 argtypetext
= strchr (demangled_name
, '(') + 1;
589 else if (*p
== ',' && depth
== 0)
594 /* We need two more slots: one for the THIS pointer, and one for the
595 NULL [...] or void [end of arglist]. */
596 argtypes
= (struct type
**) obstack_alloc (symbol_obstack
,
597 (argcount
+2) * sizeof (struct type
*));
599 argtypes
[0] = lookup_pointer_type (type
);
602 if (*p
!= ')') /* () means no args, skip while */
607 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
610 parse_and_eval_type (argtypetext
, p
- argtypetext
);
624 if (p
[-2] != '.') /* ... */
625 argtypes
[argcount
] = builtin_type_void
; /* Ellist terminator */
627 argtypes
[argcount
] = NULL
; /* List terminator */
629 free (demangled_name
);
631 f
= TYPE_FN_FIELDLIST1 (type
, i
);
632 TYPE_FN_FIELD_PHYSNAME (f
, j
) = mangled_name
;
634 /* Now update the old "stub" type into a real type. */
635 mtype
= TYPE_FN_FIELD_TYPE (f
, j
);
636 TYPE_DOMAIN_TYPE (mtype
) = type
;
637 TYPE_ARG_TYPES (mtype
) = argtypes
;
638 TYPE_FLAGS (mtype
) &= ~TYPE_FLAG_STUB
;
641 /* Given a type TYPE, return a type of functions that return that type.
642 May need to construct such a type if this is the first use. */
645 lookup_function_type (type
)
648 register struct type
*ptype
= TYPE_FUNCTION_TYPE (type
);
649 if (ptype
) return ptype
;
651 /* This is the first time anyone wanted a function returning a TYPE. */
652 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
653 ptype
= (struct type
*) xmalloc (sizeof (struct type
));
655 ptype
= (struct type
*) obstack_alloc (symbol_obstack
,
656 sizeof (struct type
));
658 bzero (ptype
, sizeof (struct type
));
659 TYPE_TARGET_TYPE (ptype
) = type
;
660 TYPE_FUNCTION_TYPE (type
) = ptype
;
661 /* New type is permanent if type returned is permanent. */
662 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
663 TYPE_FLAGS (ptype
) |= TYPE_FLAG_PERM
;
664 TYPE_LENGTH (ptype
) = 1;
665 TYPE_CODE (ptype
) = TYPE_CODE_FUNC
;
666 TYPE_NFIELDS (ptype
) = 0;
670 /* Create an array type. Elements will be of type TYPE, and there will
673 Eventually this should be extended to take two more arguments which
674 specify the bounds of the array and the type of the index.
675 It should also be changed to be a "lookup" function, with the
676 appropriate data structures added to the type field.
677 Then read array type should call here. */
680 create_array_type (element_type
, number
)
681 struct type
*element_type
;
684 struct type
*result_type
= (struct type
*)
685 obstack_alloc (symbol_obstack
, sizeof (struct type
));
686 struct type
*range_type
;
688 bzero (result_type
, sizeof (struct type
));
690 TYPE_CODE (result_type
) = TYPE_CODE_ARRAY
;
691 TYPE_TARGET_TYPE (result_type
) = element_type
;
692 TYPE_LENGTH (result_type
) = number
* TYPE_LENGTH (element_type
);
693 TYPE_NFIELDS (result_type
) = 1;
694 TYPE_FIELDS (result_type
) =
695 (struct field
*) obstack_alloc (symbol_obstack
, sizeof (struct field
));
698 /* Create range type. */
699 range_type
= (struct type
*) obstack_alloc (symbol_obstack
,
700 sizeof (struct type
));
701 TYPE_CODE (range_type
) = TYPE_CODE_RANGE
;
702 TYPE_TARGET_TYPE (range_type
) = builtin_type_int
; /* FIXME */
704 /* This should never be needed. */
705 TYPE_LENGTH (range_type
) = sizeof (int);
707 TYPE_NFIELDS (range_type
) = 2;
708 TYPE_FIELDS (range_type
) =
709 (struct field
*) obstack_alloc (symbol_obstack
,
710 2 * sizeof (struct field
));
711 TYPE_FIELD_BITPOS (range_type
, 0) = 0; /* FIXME */
712 TYPE_FIELD_BITPOS (range_type
, 1) = number
-1; /* FIXME */
713 TYPE_FIELD_TYPE (range_type
, 0) = builtin_type_int
; /* FIXME */
714 TYPE_FIELD_TYPE (range_type
, 1) = builtin_type_int
; /* FIXME */
716 TYPE_FIELD_TYPE(result_type
,0)=range_type
;
717 TYPE_VPTR_FIELDNO (result_type
) = -1;
723 /* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE.
724 A MEMBER is a wierd thing -- it amounts to a typed offset into
725 a struct, e.g. "an int at offset 8". A MEMBER TYPE doesn't
726 include the offset (that's the value of the MEMBER itself), but does
727 include the structure type into which it points (for some reason). */
730 smash_to_member_type (type
, domain
, to_type
)
731 struct type
*type
, *domain
, *to_type
;
733 bzero (type
, sizeof (struct type
));
734 TYPE_TARGET_TYPE (type
) = to_type
;
735 TYPE_DOMAIN_TYPE (type
) = domain
;
736 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
737 TYPE_CODE (type
) = TYPE_CODE_MEMBER
;
740 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
741 METHOD just means `function that gets an extra "this" argument'. */
744 smash_to_method_type (type
, domain
, to_type
, args
)
745 struct type
*type
, *domain
, *to_type
, **args
;
747 bzero (type
, sizeof (struct type
));
748 TYPE_TARGET_TYPE (type
) = to_type
;
749 TYPE_DOMAIN_TYPE (type
) = domain
;
750 TYPE_ARG_TYPES (type
) = args
;
751 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
752 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
755 /* Find which partial symtab on the partial_symtab_list contains
756 PC. Return 0 if none. */
758 struct partial_symtab
*
760 register CORE_ADDR pc
;
762 register struct partial_symtab
*ps
;
764 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
765 if (pc
>= ps
->textlow
&& pc
< ps
->texthigh
)
771 /* Find which partial symbol within a psymtab contains PC. Return 0
772 if none. Check all psymtabs if PSYMTAB is 0. */
773 struct partial_symbol
*
774 find_pc_psymbol (psymtab
, pc
)
775 struct partial_symtab
*psymtab
;
778 struct partial_symbol
*best
, *p
;
782 psymtab
= find_pc_psymtab (pc
);
786 best_pc
= psymtab
->textlow
- 1;
788 for (p
= static_psymbols
.list
+ psymtab
->statics_offset
;
789 (p
- (static_psymbols
.list
+ psymtab
->statics_offset
)
790 < psymtab
->n_static_syms
);
792 if (SYMBOL_NAMESPACE (p
) == VAR_NAMESPACE
793 && SYMBOL_CLASS (p
) == LOC_BLOCK
794 && pc
>= SYMBOL_VALUE_ADDRESS (p
)
795 && SYMBOL_VALUE_ADDRESS (p
) > best_pc
)
797 best_pc
= SYMBOL_VALUE_ADDRESS (p
);
800 if (best_pc
== psymtab
->textlow
- 1)
806 /* Find the definition for a specified symbol name NAME
807 in namespace NAMESPACE, visible from lexical block BLOCK.
808 Returns the struct symbol pointer, or zero if no symbol is found.
809 If SYMTAB is non-NULL, store the symbol table in which the
810 symbol was found there, or NULL if not found.
811 C++: if IS_A_FIELD_OF_THIS is nonzero on entry, check to see if
812 NAME is a field of the current implied argument `this'. If so set
813 *IS_A_FIELD_OF_THIS to 1, otherwise set it to zero.
814 BLOCK_FOUND is set to the block in which NAME is found (in the case of
815 a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */
818 lookup_symbol (name
, block
, namespace, is_a_field_of_this
, symtab
)
820 register struct block
*block
;
821 enum namespace namespace;
822 int *is_a_field_of_this
;
823 struct symtab
**symtab
;
825 register struct symbol
*sym
;
826 register struct symtab
*s
;
827 register struct partial_symtab
*ps
;
828 struct blockvector
*bv
;
830 /* Search specified block and its superiors. */
834 sym
= lookup_block_symbol (block
, name
, namespace);
840 /* Search the list of symtabs for one which contains the
841 address of the start of this block. */
843 for (s
= symtab_list
; s
; s
= s
->next
)
845 bv
= BLOCKVECTOR (s
);
846 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
847 if (BLOCK_START (b
) <= BLOCK_START (block
)
848 && BLOCK_END (b
) > BLOCK_START (block
))
856 block
= BLOCK_SUPERBLOCK (block
);
859 /* But that doesn't do any demangling for the STATIC_BLOCK.
860 I'm not sure whether demangling is needed in the case of
861 nested function in inner blocks; if so this needs to be changed.
863 Don't need to mess with the psymtabs; if we have a block,
864 that file is read in. If we don't, then we deal later with
865 all the psymtab stuff that needs checking. */
866 if (namespace == VAR_NAMESPACE
&& block
!= NULL
)
869 /* Find the right symtab. */
870 for (s
= symtab_list
; s
; s
= s
->next
)
872 bv
= BLOCKVECTOR (s
);
873 b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
874 if (BLOCK_START (b
) <= BLOCK_START (block
)
875 && BLOCK_END (b
) > BLOCK_START (block
))
877 sym
= lookup_demangled_block_symbol (b
, name
);
890 /* C++: If requested to do so by the caller,
891 check to see if NAME is a field of `this'. */
892 if (is_a_field_of_this
)
894 struct value
*v
= value_of_this (0);
896 *is_a_field_of_this
= 0;
897 if (v
&& check_field (v
, name
))
899 *is_a_field_of_this
= 1;
906 /* Now search all global blocks. Do the symtab's first, then
907 check the psymtab's */
909 for (s
= symtab_list
; s
; s
= s
->next
)
911 bv
= BLOCKVECTOR (s
);
912 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
913 sym
= lookup_block_symbol (block
, name
, namespace);
923 /* Check for the possibility of the symbol being a global function
924 that is stored on the misc function vector. Eventually, all
925 global symbols might be resolved in this way. */
927 if (namespace == VAR_NAMESPACE
)
929 int ind
= lookup_misc_func (name
);
931 /* Look for a mangled C++ name for NAME. */
934 int name_len
= strlen (name
);
936 for (ind
= misc_function_count
; --ind
>= 0; )
937 /* Assume orginal name is prefix of mangled name. */
938 if (!strncmp (misc_function_vector
[ind
].name
, name
, name_len
))
941 cplus_demangle(misc_function_vector
[ind
].name
, -1);
942 if (demangled
!= NULL
)
944 int cond
= strcmp (demangled
, name
);
950 /* Loop terminates on no match with ind == -1. */
955 s
= find_pc_symtab (misc_function_vector
[ind
].address
);
956 /* If S is zero, there are no debug symbols for this file.
957 Skip this stuff and check for matching static symbols below. */
960 bv
= BLOCKVECTOR (s
);
961 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
962 sym
= lookup_block_symbol (block
, misc_function_vector
[ind
].name
,
964 /* sym == 0 if symbol was found in the misc_function_vector
965 but not in the symtab.
966 Return 0 to use the misc_function definition of "foo_".
968 This happens for Fortran "foo_" symbols,
969 which are "foo" in the symtab.
971 This can also happen if "asm" is used to make a
972 regular symbol but not a debugging symbol, e.g.
984 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
985 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 1, namespace))
987 s
= PSYMTAB_TO_SYMTAB(ps
);
988 bv
= BLOCKVECTOR (s
);
989 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
990 sym
= lookup_block_symbol (block
, name
, namespace);
992 error ("Internal: global symbol `%s' found in psymtab but not in symtab", name
);
998 /* Now search all per-file blocks.
999 Not strictly correct, but more useful than an error.
1000 Do the symtabs first, then check the psymtabs */
1002 for (s
= symtab_list
; s
; s
= s
->next
)
1004 bv
= BLOCKVECTOR (s
);
1005 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1006 sym
= lookup_block_symbol (block
, name
, namespace);
1009 block_found
= block
;
1016 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
1017 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 0, namespace))
1019 s
= PSYMTAB_TO_SYMTAB(ps
);
1020 bv
= BLOCKVECTOR (s
);
1021 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1022 sym
= lookup_block_symbol (block
, name
, namespace);
1024 error ("Internal: static symbol `%s' found in psymtab but not in symtab", name
);
1030 /* Now search all per-file blocks for static mangled symbols.
1031 Do the symtabs first, then check the psymtabs. */
1033 if (namespace == VAR_NAMESPACE
)
1035 for (s
= symtab_list
; s
; s
= s
->next
)
1037 bv
= BLOCKVECTOR (s
);
1038 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1039 sym
= lookup_demangled_block_symbol (block
, name
);
1042 block_found
= block
;
1049 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
1050 if (!ps
->readin
&& lookup_demangled_partial_symbol (ps
, name
))
1052 s
= PSYMTAB_TO_SYMTAB(ps
);
1053 bv
= BLOCKVECTOR (s
);
1054 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1055 sym
= lookup_demangled_block_symbol (block
, name
);
1057 error ("Internal: mangled static symbol `%s' found in psymtab but not in symtab", name
);
1069 /* Look for a static demangled symbol in block BLOCK. */
1071 static struct symbol
*
1072 lookup_demangled_block_symbol (block
, name
)
1073 register struct block
*block
;
1076 register int bot
, top
, inc
;
1077 register struct symbol
*sym
;
1080 top
= BLOCK_NSYMS (block
);
1085 sym
= BLOCK_SYM (block
, bot
);
1086 if (SYMBOL_NAME (sym
)[0] == inc
1087 && SYMBOL_NAMESPACE (sym
) == VAR_NAMESPACE
)
1089 char *demangled
= cplus_demangle(SYMBOL_NAME (sym
), -1);
1090 if (demangled
!= NULL
)
1092 int cond
= strcmp (demangled
, name
);
1104 /* Look, in partial_symtab PST, for static mangled symbol NAME. */
1106 static struct partial_symbol
*
1107 lookup_demangled_partial_symbol (pst
, name
)
1108 struct partial_symtab
*pst
;
1111 struct partial_symbol
*start
, *psym
;
1112 int length
= pst
->n_static_syms
;
1113 register int inc
= name
[0];
1116 return (struct partial_symbol
*) 0;
1118 start
= static_psymbols
.list
+ pst
->statics_offset
;
1119 for (psym
= start
; psym
< start
+ length
; psym
++)
1121 if (SYMBOL_NAME (psym
)[0] == inc
1122 && SYMBOL_NAMESPACE (psym
) == VAR_NAMESPACE
)
1124 char *demangled
= cplus_demangle(SYMBOL_NAME (psym
), -1);
1125 if (demangled
!= NULL
)
1127 int cond
= strcmp (demangled
, name
);
1135 return (struct partial_symbol
*) 0;
1138 /* Look, in partial_symtab PST, for symbol NAME. Check the global
1139 symbols if GLOBAL, the static symbols if not */
1141 static struct partial_symbol
*
1142 lookup_partial_symbol (pst
, name
, global
, namespace)
1143 struct partial_symtab
*pst
;
1146 enum namespace namespace;
1148 struct partial_symbol
*start
, *psym
;
1149 int length
= (global
? pst
->n_global_syms
: pst
->n_static_syms
);
1152 return (struct partial_symbol
*) 0;
1155 global_psymbols
.list
+ pst
->globals_offset
:
1156 static_psymbols
.list
+ pst
->statics_offset
);
1158 if (global
) /* This means we can use a binary */
1161 struct partial_symbol
*top
, *bottom
, *center
;
1163 /* Binary search. This search is guaranteed to end with center
1164 pointing at the earliest partial symbol with the correct
1165 name. At that point *all* partial symbols with that name
1166 will be checked against the correct namespace. */
1168 top
= start
+ length
- 1;
1169 while (top
> bottom
)
1171 center
= bottom
+ (top
- bottom
) / 2;
1173 assert (center
< top
);
1175 if (strcmp (SYMBOL_NAME (center
), name
) >= 0)
1178 bottom
= center
+ 1;
1180 assert (top
== bottom
);
1182 while (!strcmp (SYMBOL_NAME (top
), name
))
1184 if (SYMBOL_NAMESPACE (top
) == namespace)
1191 /* Can't use a binary search */
1192 for (psym
= start
; psym
< start
+ length
; psym
++)
1193 if (namespace == SYMBOL_NAMESPACE (psym
)
1194 && !strcmp (name
, SYMBOL_NAME (psym
)))
1198 return (struct partial_symbol
*) 0;
1201 /* Find the psymtab containing main(). */
1203 struct partial_symtab
*
1204 find_main_psymtab ()
1206 register struct partial_symtab
*pst
;
1207 for (pst
= partial_symtab_list
; pst
; pst
= pst
->next
)
1208 if (lookup_partial_symbol (pst
, "main", 1, VAR_NAMESPACE
))
1213 /* Look for a symbol in block BLOCK. */
1216 lookup_block_symbol (block
, name
, namespace)
1217 register struct block
*block
;
1219 enum namespace namespace;
1221 register int bot
, top
, inc
;
1222 register struct symbol
*sym
, *parameter_sym
;
1224 top
= BLOCK_NSYMS (block
);
1227 /* If the blocks's symbols were sorted, start with a binary search. */
1229 if (BLOCK_SHOULD_SORT (block
))
1231 /* First, advance BOT to not far before
1232 the first symbol whose name is NAME. */
1236 inc
= (top
- bot
+ 1);
1237 /* No need to keep binary searching for the last few bits worth. */
1240 inc
= (inc
>> 1) + bot
;
1241 sym
= BLOCK_SYM (block
, inc
);
1242 if (SYMBOL_NAME (sym
)[0] < name
[0])
1244 else if (SYMBOL_NAME (sym
)[0] > name
[0])
1246 else if (strcmp (SYMBOL_NAME (sym
), name
) < 0)
1252 /* Now scan forward until we run out of symbols,
1253 find one whose name is greater than NAME,
1254 or find one we want.
1255 If there is more than one symbol with the right name and namespace,
1256 we return the first one. dbxread.c is careful to make sure
1257 that if one is a register then it comes first. */
1259 top
= BLOCK_NSYMS (block
);
1262 sym
= BLOCK_SYM (block
, bot
);
1263 inc
= SYMBOL_NAME (sym
)[0] - name
[0];
1265 inc
= strcmp (SYMBOL_NAME (sym
), name
);
1266 if (inc
== 0 && SYMBOL_NAMESPACE (sym
) == namespace)
1275 /* Here if block isn't sorted.
1276 This loop is equivalent to the loop above,
1277 but hacked greatly for speed.
1279 Note that parameter symbols do not always show up last in the
1280 list; this loop makes sure to take anything else other than
1281 parameter symbols first; it only uses parameter symbols as a
1282 last resort. Note that this only takes up extra computation
1285 parameter_sym
= (struct symbol
*) 0;
1286 top
= BLOCK_NSYMS (block
);
1290 sym
= BLOCK_SYM (block
, bot
);
1291 if (SYMBOL_NAME (sym
)[0] == inc
1292 && !strcmp (SYMBOL_NAME (sym
), name
)
1293 && SYMBOL_NAMESPACE (sym
) == namespace)
1295 if (SYMBOL_CLASS (sym
) == LOC_ARG
1296 || SYMBOL_CLASS (sym
) == LOC_LOCAL_ARG
1297 || SYMBOL_CLASS (sym
) == LOC_REF_ARG
1298 || SYMBOL_CLASS (sym
) == LOC_REGPARM
)
1299 parameter_sym
= sym
;
1305 return parameter_sym
; /* Will be 0 if not found. */
1308 /* Return the symbol for the function which contains a specified
1309 lexical block, described by a struct block BL. */
1315 while (BLOCK_FUNCTION (bl
) == 0 && BLOCK_SUPERBLOCK (bl
) != 0)
1316 bl
= BLOCK_SUPERBLOCK (bl
);
1318 return BLOCK_FUNCTION (bl
);
1321 /* Subroutine of find_pc_line */
1325 register CORE_ADDR pc
;
1327 register struct block
*b
;
1328 struct blockvector
*bv
;
1329 register struct symtab
*s
;
1330 register struct partial_symtab
*ps
;
1332 /* Search all symtabs for one whose file contains our pc */
1334 for (s
= symtab_list
; s
; s
= s
->next
)
1336 bv
= BLOCKVECTOR (s
);
1337 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1338 if (BLOCK_START (b
) <= pc
1339 && BLOCK_END (b
) > pc
)
1345 ps
= find_pc_psymtab (pc
);
1346 if (ps
&& ps
->readin
)
1348 "(Internal error: pc 0x%x in read in psymtab, but not in symtab.)\n", pc
);
1351 s
= PSYMTAB_TO_SYMTAB (ps
);
1357 /* Find the source file and line number for a given PC value.
1358 Return a structure containing a symtab pointer, a line number,
1359 and a pc range for the entire source line.
1360 The value's .pc field is NOT the specified pc.
1361 NOTCURRENT nonzero means, if specified pc is on a line boundary,
1362 use the line that ends there. Otherwise, in that case, the line
1363 that begins there is used. */
1365 struct symtab_and_line
1366 find_pc_line (pc
, notcurrent
)
1371 register struct linetable
*l
;
1374 register struct linetable_entry
*item
;
1375 struct symtab_and_line val
;
1376 struct blockvector
*bv
;
1378 /* Info on best line seen so far, and where it starts, and its file. */
1381 CORE_ADDR best_pc
= 0;
1382 CORE_ADDR best_end
= 0;
1383 struct symtab
*best_symtab
= 0;
1385 /* Store here the first line number
1386 of a file which contains the line at the smallest pc after PC.
1387 If we don't find a line whose range contains PC,
1388 we will use a line one less than this,
1389 with a range from the start of that file to the first line's pc. */
1391 CORE_ADDR alt_pc
= 0;
1392 struct symtab
*alt_symtab
= 0;
1394 /* Info on best line seen in this file. */
1399 /* Info on first line of this file. */
1404 /* If this pc is not from the current frame,
1405 it is the address of the end of a call instruction.
1406 Quite likely that is the start of the following statement.
1407 But what we want is the statement containing the instruction.
1408 Fudge the pc to make sure we get that. */
1410 if (notcurrent
) pc
-= 1;
1412 s
= find_pc_symtab (pc
);
1422 bv
= BLOCKVECTOR (s
);
1424 /* Look at all the symtabs that share this blockvector.
1425 They all have the same apriori range, that we found was right;
1426 but they have different line tables. */
1428 for (; s
&& BLOCKVECTOR (s
) == bv
; s
= s
->next
)
1430 /* Find the best line in this symtab. */
1437 for (i
= 0; i
< len
; i
++)
1439 item
= &(l
->item
[i
]);
1443 first_line
= item
->line
;
1444 first_pc
= item
->pc
;
1446 /* Return the last line that did not start after PC. */
1449 prev_line
= item
->line
;
1456 /* Is this file's best line closer than the best in the other files?
1457 If so, record this file, and its best line, as best so far. */
1458 if (prev_line
>= 0 && prev_pc
> best_pc
)
1461 best_line
= prev_line
;
1464 best_end
= item
->pc
;
1468 /* Is this file's first line closer than the first lines of other files?
1469 If so, record this file, and its first line, as best alternate. */
1470 if (first_line
>= 0 && first_pc
> pc
1471 && (alt_pc
== 0 || first_pc
< alt_pc
))
1474 alt_line
= first_line
;
1478 if (best_symtab
== 0)
1480 val
.symtab
= alt_symtab
;
1481 val
.line
= alt_line
- 1;
1482 val
.pc
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
1487 val
.symtab
= best_symtab
;
1488 val
.line
= best_line
;
1490 val
.end
= (best_end
? best_end
1492 : BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
))));
1497 /* Find the PC value for a given source file and line number.
1498 Returns zero for invalid line number.
1499 The source file is specified with a struct symtab. */
1502 find_line_pc (symtab
, line
)
1503 struct symtab
*symtab
;
1506 register struct linetable
*l
;
1512 l
= LINETABLE (symtab
);
1513 ind
= find_line_common(l
, line
, &dummy
);
1514 return (ind
>= 0) ? l
->item
[ind
].pc
: 0;
1517 /* Find the range of pc values in a line.
1518 Store the starting pc of the line into *STARTPTR
1519 and the ending pc (start of next line) into *ENDPTR.
1520 Returns 1 to indicate success.
1521 Returns 0 if could not find the specified line. */
1524 find_line_pc_range (symtab
, thisline
, startptr
, endptr
)
1525 struct symtab
*symtab
;
1527 CORE_ADDR
*startptr
, *endptr
;
1529 register struct linetable
*l
;
1531 int exact_match
; /* did we get an exact linenumber match */
1536 l
= LINETABLE (symtab
);
1537 ind
= find_line_common (l
, thisline
, &exact_match
);
1540 *startptr
= l
->item
[ind
].pc
;
1541 /* If we have not seen an entry for the specified line,
1542 assume that means the specified line has zero bytes. */
1543 if (!exact_match
|| ind
== l
->nitems
-1)
1544 *endptr
= *startptr
;
1546 /* Perhaps the following entry is for the following line.
1547 It's worth a try. */
1548 if (ind
+1 < l
->nitems
1549 && l
->item
[ind
+1].line
== thisline
+ 1)
1550 *endptr
= l
->item
[ind
+1].pc
;
1552 *endptr
= find_line_pc (symtab
, thisline
+1);
1559 /* Given a line table and a line number, return the index into the line
1560 table for the pc of the nearest line whose number is >= the specified one.
1561 Return -1 if none is found. The value is >= 0 if it is an index.
1563 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
1566 find_line_common (l
, lineno
, exact_match
)
1567 register struct linetable
*l
;
1568 register int lineno
;
1574 /* BEST is the smallest linenumber > LINENO so far seen,
1575 or 0 if none has been seen so far.
1576 BEST_INDEX identifies the item for it. */
1578 int best_index
= -1;
1587 for (i
= 0; i
< len
; i
++)
1589 register struct linetable_entry
*item
= &(l
->item
[i
]);
1591 if (item
->line
== lineno
)
1597 if (item
->line
> lineno
&& (best
== 0 || item
->line
< best
))
1604 /* If we got here, we didn't get an exact match. */
1611 find_pc_line_pc_range (pc
, startptr
, endptr
)
1613 CORE_ADDR
*startptr
, *endptr
;
1615 struct symtab_and_line sal
;
1616 sal
= find_pc_line (pc
, 0);
1619 return sal
.symtab
!= 0;
1622 /* If P is of the form "operator[ \t]+..." where `...' is
1623 some legitimate operator text, return a pointer to the
1624 beginning of the substring of the operator text.
1625 Otherwise, return "". */
1627 operator_chars (p
, end
)
1632 if (strncmp (p
, "operator", 8))
1636 /* Don't get faked out by `operator' being part of a longer
1638 if ((*p
>= 'A' && *p
<= 'Z') || (*p
>= 'a' && *p
<= 'z')
1639 || *p
== '_' || *p
== '$' || *p
== '\0')
1642 /* Allow some whitespace between `operator' and the operator symbol. */
1643 while (*p
== ' ' || *p
== '\t')
1665 if (p
[1] == '=' || p
[1] == p
[0])
1676 error ("`operator ()' must be specified without whitespace in `()'");
1681 error ("`operator ?:' must be specified without whitespace in `?:'");
1686 error ("`operator []' must be specified without whitespace in `[]'");
1690 error ("`operator %s' not supported", p
);
1697 /* Recursive helper function for decode_line_1.
1698 * Look for methods named NAME in type T.
1699 * Return number of matches.
1700 * Put matches in PHYSNAMES and SYM_ARR (which better be big enough!).
1701 * These allocations seem to define "big enough":
1702 * sym_arr = (struct symbol **) alloca(TYPE_NFN_FIELDS_TOTAL (t) * sizeof(struct symbol*));
1703 * physnames = (char **) alloca (TYPE_NFN_FIELDS_TOTAL (t) * sizeof(char*));
1707 find_methods(t
, name
, physnames
, sym_arr
)
1711 struct symbol
**sym_arr
;
1715 struct symbol
*sym_class
;
1716 char *class_name
= type_name_no_tag (t
);
1717 /* Ignore this class if it doesn't have a name.
1718 This prevents core dumps, but is just a workaround
1719 because we might not find the function in
1720 certain cases, such as
1721 struct D {virtual int f();}
1722 struct C : D {virtual int g();}
1723 (in this case g++ 1.35.1- does not put out a name
1724 for D as such, it defines type 19 (for example) in
1725 the same stab as C, and then does a
1726 .stabs "D:T19" and a .stabs "D:t19".
1728 "break C::f" should not be looking for field f in
1730 but just for the field f in the baseclasses of C
1731 (no matter what their names).
1733 However, I don't know how to replace the code below
1734 that depends on knowing the name of D. */
1736 && (sym_class
= lookup_symbol (class_name
,
1737 (struct block
*)NULL
,
1740 (struct symtab
**)NULL
)))
1743 t
= SYMBOL_TYPE (sym_class
);
1744 for (method_counter
= TYPE_NFN_FIELDS (t
) - 1;
1745 method_counter
>= 0;
1749 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, method_counter
);
1751 char *method_name
= TYPE_FN_FIELDLIST_NAME (t
, method_counter
);
1752 if (!strcmp (name
, method_name
))
1753 /* Find all the fields with that name. */
1754 for (field_counter
= TYPE_FN_FIELDLIST_LENGTH (t
, method_counter
) - 1;
1759 if (TYPE_FLAGS (TYPE_FN_FIELD_TYPE (f
, field_counter
)) & TYPE_FLAG_STUB
)
1760 check_stub_method (t
, method_counter
, field_counter
);
1761 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, field_counter
);
1762 physnames
[i1
] = (char*) alloca (strlen (phys_name
) + 1);
1763 strcpy (physnames
[i1
], phys_name
);
1764 sym_arr
[i1
] = lookup_symbol (phys_name
,
1765 SYMBOL_BLOCK_VALUE (sym_class
),
1768 (struct symtab
**) NULL
);
1769 if (sym_arr
[i1
]) i1
++;
1773 /* Only search baseclasses if there is no match yet,
1774 * since names in derived classes override those in baseclasses.
1778 for (ibase
= 0; ibase
< TYPE_N_BASECLASSES (t
); ibase
++)
1779 i1
+= find_methods(TYPE_BASECLASS(t
, ibase
), name
,
1780 physnames
+ i1
, sym_arr
+ i1
);
1784 /* Parse a string that specifies a line number.
1785 Pass the address of a char * variable; that variable will be
1786 advanced over the characters actually parsed.
1790 LINENUM -- that line number in current file. PC returned is 0.
1791 FILE:LINENUM -- that line in that file. PC returned is 0.
1792 FUNCTION -- line number of openbrace of that function.
1793 PC returned is the start of the function.
1794 VARIABLE -- line number of definition of that variable.
1796 FILE:FUNCTION -- likewise, but prefer functions in that file.
1797 *EXPR -- line in which address EXPR appears.
1799 FUNCTION may be an undebuggable function found in misc_function_vector.
1801 If the argument FUNFIRSTLINE is nonzero, we want the first line
1802 of real code inside a function when a function is specified.
1804 DEFAULT_SYMTAB specifies the file to use if none is specified.
1805 It defaults to current_source_symtab.
1806 DEFAULT_LINE specifies the line number to use for relative
1807 line numbers (that start with signs). Defaults to current_source_line.
1809 Note that it is possible to return zero for the symtab
1810 if no file is validly specified. Callers must check that.
1811 Also, the line number returned may be invalid. */
1813 struct symtabs_and_lines
1814 decode_line_1 (argptr
, funfirstline
, default_symtab
, default_line
)
1817 struct symtab
*default_symtab
;
1820 struct symtabs_and_lines
decode_line_2 ();
1821 struct symtabs_and_lines values
;
1822 struct symtab_and_line val
;
1823 register char *p
, *p1
;
1825 register struct symtab
*s
;
1827 register struct symbol
*sym
;
1828 /* The symtab that SYM was found in. */
1829 struct symtab
*sym_symtab
;
1831 register CORE_ADDR pc
;
1834 struct symbol
*sym_class
;
1836 struct symbol
**sym_arr
;
1840 /* Defaults have defaults. */
1842 if (default_symtab
== 0)
1844 default_symtab
= current_source_symtab
;
1845 default_line
= current_source_line
;
1848 /* See if arg is *PC */
1850 if (**argptr
== '*')
1853 pc
= parse_and_eval_address_1 (argptr
);
1854 values
.sals
= (struct symtab_and_line
*)
1855 xmalloc (sizeof (struct symtab_and_line
));
1857 values
.sals
[0] = find_pc_line (pc
, 0);
1858 values
.sals
[0].pc
= pc
;
1862 /* Maybe arg is FILE : LINENUM or FILE : FUNCTION */
1866 for (p
= *argptr
; *p
; p
++)
1868 if (p
[0] == ':' || p
[0] == ' ' || p
[0] == '\t')
1871 while (p
[0] == ' ' || p
[0] == '\t') p
++;
1879 /* Extract the class name. */
1881 while (p
!= *argptr
&& p
[-1] == ' ') --p
;
1882 copy
= (char *) alloca (p
- *argptr
+ 1);
1883 bcopy (*argptr
, copy
, p
- *argptr
);
1884 copy
[p
- *argptr
] = 0;
1886 /* Discard the class name from the arg. */
1888 while (*p
== ' ' || *p
== '\t') p
++;
1891 sym_class
= lookup_symbol (copy
, 0, STRUCT_NAMESPACE
, 0,
1892 (struct symtab
**)NULL
);
1895 ( TYPE_CODE (SYMBOL_TYPE (sym_class
)) == TYPE_CODE_STRUCT
1896 || TYPE_CODE (SYMBOL_TYPE (sym_class
)) == TYPE_CODE_UNION
))
1898 /* Arg token is not digits => try it as a function name
1899 Find the next token (everything up to end or next whitespace). */
1901 while (*p
&& *p
!= ' ' && *p
!= '\t' && *p
!= ',' && *p
!=':') p
++;
1902 q
= operator_chars (*argptr
, &q1
);
1904 copy
= (char *) alloca (p
- *argptr
+ 1 + (q1
- q
));
1909 copy
[2] = CPLUS_MARKER
;
1910 bcopy (q
, copy
+ 3, q1
- q
);
1911 copy
[3 + (q1
- q
)] = '\0';
1916 bcopy (*argptr
, copy
, p
- *argptr
);
1917 copy
[p
- *argptr
] = '\0';
1920 /* no line number may be specified */
1921 while (*p
== ' ' || *p
== '\t') p
++;
1925 i1
= 0; /* counter for the symbol array */
1926 t
= SYMBOL_TYPE (sym_class
);
1927 sym_arr
= (struct symbol
**) alloca(TYPE_NFN_FIELDS_TOTAL (t
) * sizeof(struct symbol
*));
1928 physnames
= (char **) alloca (TYPE_NFN_FIELDS_TOTAL (t
) * sizeof(char*));
1930 if (destructor_name_p (copy
, t
))
1932 /* destructors are a special case. */
1933 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, 0);
1934 int len
= TYPE_FN_FIELDLIST_LENGTH (t
, 0) - 1;
1935 char *phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, len
);
1936 physnames
[i1
] = (char *)alloca (strlen (phys_name
) + 1);
1937 strcpy (physnames
[i1
], phys_name
);
1939 lookup_symbol (phys_name
, SYMBOL_BLOCK_VALUE (sym_class
),
1940 VAR_NAMESPACE
, 0, (struct symtab
**)NULL
);
1941 if (sym_arr
[i1
]) i1
++;
1944 i1
= find_methods (t
, copy
, physnames
, sym_arr
);
1947 /* There is exactly one field with that name. */
1950 if (sym
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
)
1952 /* Arg is the name of a function */
1953 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) + FUNCTION_START_OFFSET
;
1956 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
1958 values
.sals
[0] = find_pc_line (pc
, 0);
1959 values
.sals
[0].pc
= (values
.sals
[0].end
&& values
.sals
[0].pc
!= pc
) ? values
.sals
[0].end
: pc
;
1969 /* There is more than one field with that name
1970 (overloaded). Ask the user which one to use. */
1971 return decode_line_2 (sym_arr
, i1
, funfirstline
);
1977 if (OPNAME_PREFIX_P (copy
))
1979 tmp
= (char *)alloca (strlen (copy
+3) + 9);
1980 strcpy (tmp
, "operator ");
1981 strcat (tmp
, copy
+3);
1986 error ("The class `%s' does not have destructor defined",
1989 error ("The class %s does not have any method named %s",
1990 sym_class
->name
, tmp
);
1994 /* The quotes are important if copy is empty. */
1995 error("No class, struct, or union named \"%s\"", copy
);
2000 /* Extract the file name. */
2002 while (p
!= *argptr
&& p
[-1] == ' ') --p
;
2003 copy
= (char *) alloca (p
- *argptr
+ 1);
2004 bcopy (*argptr
, copy
, p
- *argptr
);
2005 copy
[p
- *argptr
] = 0;
2007 /* Find that file's data. */
2008 s
= lookup_symtab (copy
);
2011 if (symtab_list
== 0 && partial_symtab_list
== 0)
2012 error (no_symtab_msg
);
2013 error ("No source file named %s.", copy
);
2016 /* Discard the file name from the arg. */
2018 while (*p
== ' ' || *p
== '\t') p
++;
2022 /* S is specified file's symtab, or 0 if no file specified.
2023 arg no longer contains the file name. */
2025 /* Check whether arg is all digits (and sign) */
2028 if (*p
== '-' || *p
== '+') p
++;
2029 while (*p
>= '0' && *p
<= '9')
2032 if (p
!= *argptr
&& (*p
== 0 || *p
== ' ' || *p
== '\t' || *p
== ','))
2034 /* We found a token consisting of all digits -- at least one digit. */
2035 enum sign
{none
, plus
, minus
} sign
= none
;
2037 /* This is where we need to make sure that we have good defaults.
2038 We must guarantee that this section of code is never executed
2039 when we are called with just a function name, since
2040 select_source_symtab calls us with such an argument */
2042 if (s
== 0 && default_symtab
== 0)
2044 select_source_symtab (0);
2045 default_symtab
= current_source_symtab
;
2046 default_line
= current_source_line
;
2049 if (**argptr
== '+')
2050 sign
= plus
, (*argptr
)++;
2051 else if (**argptr
== '-')
2052 sign
= minus
, (*argptr
)++;
2053 val
.line
= atoi (*argptr
);
2060 val
.line
= default_line
+ val
.line
;
2066 val
.line
= default_line
- val
.line
;
2071 break; /* No need to adjust val.line. */
2074 while (*p
== ' ' || *p
== '\t') p
++;
2080 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
2081 values
.sals
[0] = val
;
2086 /* Arg token is not digits => try it as a variable name
2087 Find the next token (everything up to end or next whitespace). */
2089 while (*p
&& *p
!= ' ' && *p
!= '\t' && *p
!= ',') p
++;
2090 copy
= (char *) alloca (p
- *argptr
+ 1);
2091 bcopy (*argptr
, copy
, p
- *argptr
);
2092 copy
[p
- *argptr
] = 0;
2093 while (*p
== ' ' || *p
== '\t') p
++;
2096 /* Look up that token as a variable.
2097 If file specified, use that file's per-file block to start with. */
2099 sym
= lookup_symbol (copy
,
2100 (s
? BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)
2101 : get_selected_block ()),
2102 VAR_NAMESPACE
, 0, &sym_symtab
);
2106 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2108 /* Arg is the name of a function */
2109 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) + FUNCTION_START_OFFSET
;
2112 val
= find_pc_line (pc
, 0);
2113 #ifdef PROLOGUE_FIRSTLINE_OVERLAP
2114 /* Convex: no need to suppress code on first line, if any */
2117 /* If SKIP_PROLOGUE left us in mid-line, and the next line is still
2118 part of the same function:
2119 advance to next line,
2120 recalculate its line number (might not be N+1). */
2121 if (val
.pc
!= pc
&& val
.end
&&
2122 find_pc_misc_function (pc
) == find_pc_misc_function (val
.end
)) {
2123 pc
= val
.end
; /* First pc of next line */
2124 val
= find_pc_line (pc
, 0);
2128 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
2129 values
.sals
[0] = val
;
2132 /* I think this is always the same as the line that
2133 we calculate above, but the general principle is
2134 "trust the symbols more than stuff like
2136 if (SYMBOL_LINE (sym
) != 0)
2137 values
.sals
[0].line
= SYMBOL_LINE (sym
);
2141 else if (SYMBOL_LINE (sym
) != 0)
2143 /* We know its line number. */
2144 values
.sals
= (struct symtab_and_line
*)
2145 xmalloc (sizeof (struct symtab_and_line
));
2147 bzero (&values
.sals
[0], sizeof (values
.sals
[0]));
2148 values
.sals
[0].symtab
= sym_symtab
;
2149 values
.sals
[0].line
= SYMBOL_LINE (sym
);
2153 /* This can happen if it is compiled with a compiler which doesn't
2154 put out line numbers for variables. */
2155 error ("Line number not known for symbol \"%s\"", copy
);
2158 if ((i
= lookup_misc_func (copy
)) >= 0)
2162 val
.pc
= misc_function_vector
[i
].address
+ FUNCTION_START_OFFSET
;
2164 SKIP_PROLOGUE (val
.pc
);
2165 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
2166 values
.sals
[0] = val
;
2171 if (symtab_list
== 0 && partial_symtab_list
== 0 && misc_function_count
== 0)
2172 error (no_symtab_msg
);
2174 error ("Function %s not defined.", copy
);
2175 return values
; /* for lint */
2178 struct symtabs_and_lines
2179 decode_line_spec (string
, funfirstline
)
2183 struct symtabs_and_lines sals
;
2185 error ("Empty line specification.");
2186 sals
= decode_line_1 (&string
, funfirstline
,
2187 current_source_symtab
, current_source_line
);
2189 error ("Junk at end of line specification: %s", string
);
2193 /* Given a list of NELTS symbols in sym_arr (with corresponding
2194 mangled names in physnames), return a list of lines to operate on
2195 (ask user if necessary). */
2196 struct symtabs_and_lines
2197 decode_line_2 (sym_arr
, nelts
, funfirstline
)
2198 struct symbol
*sym_arr
[];
2202 struct symtabs_and_lines values
, return_values
;
2203 register CORE_ADDR pc
;
2204 char *args
, *arg1
, *command_line_input ();
2208 values
.sals
= (struct symtab_and_line
*) alloca (nelts
* sizeof(struct symtab_and_line
));
2209 return_values
.sals
= (struct symtab_and_line
*) xmalloc (nelts
* sizeof(struct symtab_and_line
));
2212 printf("[0] cancel\n[1] all\n");
2215 if (sym_arr
[i
] && SYMBOL_CLASS (sym_arr
[i
]) == LOC_BLOCK
)
2217 /* Arg is the name of a function */
2218 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym_arr
[i
]))
2219 + FUNCTION_START_OFFSET
;
2222 values
.sals
[i
] = find_pc_line (pc
, 0);
2223 values
.sals
[i
].pc
= (values
.sals
[i
].end
&& values
.sals
[i
].pc
!= pc
) ?
2224 values
.sals
[i
].end
: pc
;
2225 printf("[%d] file:%s; line number:%d\n",
2226 (i
+2), values
.sals
[i
].symtab
->filename
, values
.sals
[i
].line
);
2228 else printf ("?HERE\n");
2232 if ((prompt
= getenv ("PS2")) == NULL
)
2236 printf("%s ",prompt
);
2239 args
= command_line_input (0, 0);
2242 error_no_arg ("one or more choice numbers");
2250 while (*arg1
>= '0' && *arg1
<= '9') arg1
++;
2251 if (*arg1
&& *arg1
!= ' ' && *arg1
!= '\t')
2252 error ("Arguments must be choice numbers.");
2257 error ("cancelled");
2260 bcopy (values
.sals
, return_values
.sals
, (nelts
* sizeof(struct symtab_and_line
)));
2261 return_values
.nelts
= nelts
;
2262 return return_values
;
2265 if (num
> nelts
+ 2)
2267 printf ("No choice number %d.\n", num
);
2272 if (values
.sals
[num
].pc
)
2274 return_values
.sals
[i
++] = values
.sals
[num
];
2275 values
.sals
[num
].pc
= 0;
2279 printf ("duplicate request for %d ignored.\n", num
);
2284 while (*args
== ' ' || *args
== '\t') args
++;
2286 return_values
.nelts
= i
;
2287 return return_values
;
2290 /* Return the index of misc function named NAME. */
2293 lookup_misc_func (name
)
2294 register char *name
;
2298 for (i
= 0; i
< misc_function_count
; i
++)
2299 if (!strcmp (misc_function_vector
[i
].name
, name
))
2301 return -1; /* not found */
2304 /* Slave routine for sources_info. Force line breaks at ,'s.
2305 NAME is the name to print and *FIRST is nonzero if this is the first
2306 name printed. Set *FIRST to zero. */
2308 output_source_filename (name
, first
)
2313 /* Table of files printed so far. Since a single source file can
2314 result in several partial symbol tables, we need to avoid printing
2315 it more than once. Note: if some of the psymtabs are read in and
2316 some are not, it gets printed both under "Source files for which
2317 symbols have been read" and "Source files for which symbols will
2318 be read in on demand". I consider this a reasonable way to deal
2319 with the situation. I'm not sure whether this can also happen for
2320 symtabs; it doesn't hurt to check. */
2321 static char **tab
= NULL
;
2322 /* Allocated size of tab in elements.
2323 Start with one 256-byte block (when using GNU malloc.c).
2324 24 is the malloc overhead when range checking is in effect. */
2325 static int tab_alloc_size
= (256 - 24) / sizeof (char *);
2326 /* Current size of tab in elements. */
2327 static int tab_cur_size
;
2334 tab
= (char **) xmalloc (tab_alloc_size
* sizeof (*tab
));
2338 /* Is NAME in tab? */
2339 for (p
= tab
; p
< tab
+ tab_cur_size
; p
++)
2340 if (strcmp (*p
, name
) == 0)
2341 /* Yes; don't print it again. */
2343 /* No; add it to tab. */
2344 if (tab_cur_size
== tab_alloc_size
)
2346 tab_alloc_size
*= 2;
2347 tab
= (char **) xrealloc (tab
, tab_alloc_size
* sizeof (*tab
));
2349 tab
[tab_cur_size
++] = name
;
2358 printf_filtered (",");
2362 if (column
!= 0 && column
+ strlen (name
) >= 70)
2364 printf_filtered ("\n");
2367 else if (column
!= 0)
2369 printf_filtered (" ");
2372 fputs_filtered (name
, stdout
);
2373 column
+= strlen (name
);
2379 register struct symtab
*s
;
2380 register struct partial_symtab
*ps
;
2383 if (symtab_list
== 0 && partial_symtab_list
== 0)
2385 error (no_symtab_msg
);
2388 printf_filtered ("Source files for which symbols have been read in:\n\n");
2391 for (s
= symtab_list
; s
; s
= s
->next
)
2392 output_source_filename (s
->filename
, &first
);
2393 printf_filtered ("\n\n");
2395 printf_filtered ("Source files for which symbols will be read in on demand:\n\n");
2398 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
2400 output_source_filename (ps
->filename
, &first
);
2401 printf_filtered ("\n");
2404 /* List all symbols (if REGEXP is 0) or all symbols matching REGEXP.
2405 If CLASS is zero, list all symbols except functions and type names.
2406 If CLASS is 1, list only functions.
2407 If CLASS is 2, list only type names.
2408 If CLASS is 3, list only method names.
2410 BPT is non-zero if we should set a breakpoint at the functions
2414 list_symbols (regexp
, class, bpt
)
2419 register struct symtab
*s
;
2420 register struct partial_symtab
*ps
;
2421 register struct blockvector
*bv
;
2422 struct blockvector
*prev_bv
= 0;
2423 register struct block
*b
;
2425 register struct symbol
*sym
;
2426 struct partial_symbol
*psym
;
2428 static char *classnames
[]
2429 = {"variable", "function", "type", "method"};
2430 int found_in_file
= 0;
2432 static enum misc_function_type types
[]
2433 = {mf_data
, mf_text
, mf_abs
, mf_unknown
};
2434 static enum misc_function_type types2
[]
2435 = {mf_bss
, mf_text
, mf_abs
, mf_unknown
};
2436 enum misc_function_type ourtype
= types
[class];
2437 enum misc_function_type ourtype2
= types2
[class];
2440 if (0 != (val
= re_comp (regexp
)))
2441 error ("Invalid regexp (%s): %s", val
, regexp
);
2443 /* Search through the partial_symtab_list *first* for all symbols
2444 matching the regexp. That way we don't have to reproduce all of
2445 the machinery below. */
2446 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
2448 struct partial_symbol
*bound
, *gbound
, *sbound
;
2451 if (ps
->readin
) continue;
2453 gbound
= global_psymbols
.list
+ ps
->globals_offset
+ ps
->n_global_syms
;
2454 sbound
= static_psymbols
.list
+ ps
->statics_offset
+ ps
->n_static_syms
;
2457 /* Go through all of the symbols stored in a partial
2458 symtab in one loop. */
2459 psym
= global_psymbols
.list
+ ps
->globals_offset
;
2464 if (bound
== gbound
&& ps
->n_static_syms
!= 0)
2466 psym
= static_psymbols
.list
+ ps
->statics_offset
;
2477 /* If it would match (logic taken from loop below)
2478 load the file and go on to the next one */
2479 if ((regexp
== 0 || re_exec (SYMBOL_NAME (psym
)))
2480 && ((class == 0 && SYMBOL_CLASS (psym
) != LOC_TYPEDEF
2481 && SYMBOL_CLASS (psym
) != LOC_BLOCK
)
2482 || (class == 1 && SYMBOL_CLASS (psym
) == LOC_BLOCK
)
2483 || (class == 2 && SYMBOL_CLASS (psym
) == LOC_TYPEDEF
)
2484 || (class == 3 && SYMBOL_CLASS (psym
) == LOC_BLOCK
)))
2486 (void) PSYMTAB_TO_SYMTAB(ps
);
2494 /* Here, we search through the misc function vector for functions that
2495 match, and call find_pc_symtab on them to force their symbols to
2496 be read. The symbol will then be found during the scan of symtabs
2497 below. If find_pc_symtab fails, set found_misc so that we will
2498 rescan to print any matching symbols without debug info. */
2501 for (i
= 0; i
< misc_function_count
; i
++) {
2502 if (misc_function_vector
[i
].type
!= ourtype
2503 && misc_function_vector
[i
].type
!= ourtype2
)
2505 if (regexp
== 0 || re_exec (misc_function_vector
[i
].name
)) {
2506 if (0 == find_pc_symtab (misc_function_vector
[i
].address
))
2512 /* Printout here so as to get after the "Reading in symbols"
2513 messages which will be generated above. */
2515 printf_filtered (regexp
2516 ? "All %ss matching regular expression \"%s\":\n"
2517 : "All defined %ss:\n",
2521 for (s
= symtab_list
; s
; s
= s
->next
)
2524 bv
= BLOCKVECTOR (s
);
2525 /* Often many files share a blockvector.
2526 Scan each blockvector only once so that
2527 we don't get every symbol many times.
2528 It happens that the first symtab in the list
2529 for any given blockvector is the main file. */
2531 for (i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; i
++)
2533 b
= BLOCKVECTOR_BLOCK (bv
, i
);
2534 /* Skip the sort if this block is always sorted. */
2535 if (!BLOCK_SHOULD_SORT (b
))
2536 sort_block_syms (b
);
2537 for (j
= 0; j
< BLOCK_NSYMS (b
); j
++)
2540 sym
= BLOCK_SYM (b
, j
);
2541 if ((regexp
== 0 || re_exec (SYMBOL_NAME (sym
)))
2542 && ((class == 0 && SYMBOL_CLASS (sym
) != LOC_TYPEDEF
2543 && SYMBOL_CLASS (sym
) != LOC_BLOCK
)
2544 || (class == 1 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2545 || (class == 2 && SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
2546 || (class == 3 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)))
2550 /* Set a breakpoint here, if it's a function */
2552 break_command (SYMBOL_NAME(sym
), 0);
2554 else if (!found_in_file
)
2556 fputs_filtered ("\nFile ", stdout
);
2557 fputs_filtered (s
->filename
, stdout
);
2558 fputs_filtered (":\n", stdout
);
2562 if (class != 2 && i
== STATIC_BLOCK
)
2563 printf_filtered ("static ");
2565 /* Typedef that is not a C++ class */
2567 && SYMBOL_NAMESPACE (sym
) != STRUCT_NAMESPACE
)
2568 typedef_print (SYMBOL_TYPE(sym
), sym
, stdout
);
2569 /* variable, func, or typedef-that-is-c++-class */
2570 else if (class < 2 ||
2572 SYMBOL_NAMESPACE(sym
) == STRUCT_NAMESPACE
))
2574 type_print (SYMBOL_TYPE (sym
),
2575 (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
2576 ? "" : SYMBOL_NAME (sym
)),
2579 printf_filtered (";\n");
2585 type_print_base (TYPE_FN_FIELD_TYPE(t
, i
), stdout
, 0, 0);
2586 type_print_varspec_prefix (TYPE_FN_FIELD_TYPE(t
, i
), stdout
, 0);
2587 sprintf (buf
, " %s::", type_name_no_tag (t
));
2588 type_print_method_args (TYPE_FN_FIELD_ARGS (t
, i
), buf
, name
, stdout
);
2598 /* If there are no eyes, avoid all contact. I mean, if there are
2599 no debug symbols, then print directly from the misc_function_vector. */
2601 if (found_misc
|| class != 1) {
2603 for (i
= 0; i
< misc_function_count
; i
++) {
2604 if (misc_function_vector
[i
].type
!= ourtype
2605 && misc_function_vector
[i
].type
!= ourtype2
)
2607 if (regexp
== 0 || re_exec (misc_function_vector
[i
].name
)) {
2608 /* Functions: Look up by address. */
2610 if (0 != find_pc_symtab (misc_function_vector
[i
].address
))
2612 /* Variables/Absolutes: Look up by name */
2613 if (0 != lookup_symbol (misc_function_vector
[i
].name
,
2614 (struct block
*)0, VAR_NAMESPACE
, 0, (struct symtab
**)0))
2616 if (!found_in_file
) {
2617 printf_filtered ("\nNon-debugging symbols:\n");
2620 printf_filtered (" %08x %s\n",
2621 misc_function_vector
[i
].address
,
2622 misc_function_vector
[i
].name
);
2629 variables_info (regexp
)
2632 list_symbols (regexp
, 0, 0);
2636 functions_info (regexp
)
2639 list_symbols (regexp
, 1, 0);
2646 list_symbols (regexp
, 2, 0);
2650 /* Tiemann says: "info methods was never implemented." */
2652 methods_info (regexp
)
2655 list_symbols (regexp
, 3, 0);
2659 /* Breakpoint all functions matching regular expression. */
2661 rbreak_command (regexp
)
2664 list_symbols (regexp
, 1, 1);
2667 /* Helper function to initialize the standard scalar types. */
2670 init_type (code
, length
, uns
, name
)
2671 enum type_code code
;
2675 register struct type
*type
;
2677 type
= (struct type
*) xmalloc (sizeof (struct type
));
2678 bzero (type
, sizeof *type
);
2679 TYPE_CODE (type
) = code
;
2680 TYPE_LENGTH (type
) = length
;
2681 TYPE_FLAGS (type
) = uns
? TYPE_FLAG_UNSIGNED
: 0;
2682 TYPE_FLAGS (type
) |= TYPE_FLAG_PERM
;
2683 TYPE_NFIELDS (type
) = 0;
2684 TYPE_NAME (type
) = name
;
2687 if (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
2689 TYPE_CPLUS_SPECIFIC (type
)
2690 = (struct cplus_struct_type
*) xmalloc (sizeof (struct cplus_struct_type
));
2691 TYPE_NFN_FIELDS (type
) = 0;
2692 TYPE_N_BASECLASSES (type
) = 0;
2697 /* Return Nonzero if block a is lexically nested within block b,
2698 or if a and b have the same pc range.
2699 Return zero otherwise. */
2702 struct block
*a
, *b
;
2706 return BLOCK_START (a
) >= BLOCK_START (b
)
2707 && BLOCK_END (a
) <= BLOCK_END (b
);
2711 /* Helper routine for make_symbol_completion_list. */
2713 int return_val_size
, return_val_index
;
2717 completion_list_add_symbol (symname
)
2720 if (return_val_index
+ 3 > return_val_size
)
2722 (char **)xrealloc (return_val
,
2723 (return_val_size
*= 2) * sizeof (char *));
2725 return_val
[return_val_index
] =
2726 (char *)xmalloc (1 + strlen (symname
));
2728 strcpy (return_val
[return_val_index
], symname
);
2730 return_val
[++return_val_index
] = (char *)NULL
;
2733 /* Return a NULL terminated array of all symbols (regardless of class) which
2734 begin by matching TEXT. If the answer is no symbols, then the return value
2735 is an array which contains only a NULL pointer.
2737 Problem: All of the symbols have to be copied because readline
2738 frees them. I'm not going to worry about this; hopefully there
2739 won't be that many. */
2742 make_symbol_completion_list (text
)
2745 register struct symtab
*s
;
2746 register struct partial_symtab
*ps
;
2747 register struct block
*b
, *surrounding_static_block
= 0;
2748 extern struct block
*get_selected_block ();
2750 struct partial_symbol
*psym
;
2752 int text_len
= strlen (text
);
2753 return_val_size
= 100;
2754 return_val_index
= 0;
2756 (char **)xmalloc ((1 + return_val_size
) *sizeof (char *));
2757 return_val
[0] = (char *)NULL
;
2759 /* Look through the partial symtabs for all symbols which begin
2760 by matching TEXT. Add each one that you find to the list. */
2762 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
2764 /* If the psymtab's been read in we'll get it when we search
2765 through the blockvector. */
2766 if (ps
->readin
) continue;
2768 for (psym
= global_psymbols
.list
+ ps
->globals_offset
;
2769 psym
< (global_psymbols
.list
+ ps
->globals_offset
2770 + ps
->n_global_syms
);
2773 QUIT
; /* If interrupted, then quit. */
2774 if ((strncmp (SYMBOL_NAME (psym
), text
, text_len
) == 0))
2775 completion_list_add_symbol (SYMBOL_NAME (psym
));
2778 for (psym
= static_psymbols
.list
+ ps
->statics_offset
;
2779 psym
< (static_psymbols
.list
+ ps
->statics_offset
2780 + ps
->n_static_syms
);
2784 if ((strncmp (SYMBOL_NAME (psym
), text
, text_len
) == 0))
2785 completion_list_add_symbol (SYMBOL_NAME (psym
));
2789 /* At this point scan through the misc function vector and add each
2790 symbol you find to the list. Eventually we want to ignore
2791 anything that isn't a text symbol (everything else will be
2792 handled by the psymtab code above). */
2794 for (i
= 0; i
< misc_function_count
; i
++)
2795 if (!strncmp (text
, misc_function_vector
[i
].name
, text_len
))
2796 completion_list_add_symbol (misc_function_vector
[i
].name
);
2798 /* Search upwards from currently selected frame (so that we can
2799 complete on local vars. */
2800 for (b
= get_selected_block (); b
; b
= BLOCK_SUPERBLOCK (b
))
2802 if (!BLOCK_SUPERBLOCK (b
))
2803 surrounding_static_block
= b
; /* For elmin of dups */
2805 /* Also catch fields of types defined in this places which
2806 match our text string. Only complete on types visible
2807 from current context. */
2808 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2810 register struct symbol
*sym
= BLOCK_SYM (b
, i
);
2812 if (!strncmp (SYMBOL_NAME (sym
), text
, text_len
))
2813 completion_list_add_symbol (SYMBOL_NAME (sym
));
2815 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
2817 struct type
*t
= SYMBOL_TYPE (sym
);
2818 enum type_code c
= TYPE_CODE (t
);
2820 if (c
== TYPE_CODE_UNION
|| c
== TYPE_CODE_STRUCT
)
2821 for (j
= TYPE_N_BASECLASSES (t
); j
< TYPE_NFIELDS (t
); j
++)
2822 if (TYPE_FIELD_NAME (t
, j
) &&
2823 !strncmp (TYPE_FIELD_NAME (t
, j
), text
, text_len
))
2824 completion_list_add_symbol (TYPE_FIELD_NAME (t
, j
));
2829 /* Go through the symtabs and check the externs and statics for
2830 symbols which match. */
2832 for (s
= symtab_list
; s
; s
= s
->next
)
2834 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
2836 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2837 if (!strncmp (SYMBOL_NAME (BLOCK_SYM (b
, i
)), text
, text_len
))
2838 completion_list_add_symbol (SYMBOL_NAME (BLOCK_SYM (b
, i
)));
2841 for (s
= symtab_list
; s
; s
= s
->next
)
2843 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
2845 /* Don't do this block twice. */
2846 if (b
== surrounding_static_block
) continue;
2848 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2849 if (!strncmp (SYMBOL_NAME (BLOCK_SYM (b
, i
)), text
, text_len
))
2850 completion_list_add_symbol (SYMBOL_NAME (BLOCK_SYM (b
, i
)));
2853 return (return_val
);
2857 /* Add the type of the symbol sym to the type of the current
2858 function whose block we are in (assumed). The type of
2859 this current function is contained in *TYPE.
2861 This basically works as follows: When we find a function
2862 symbol (N_FUNC with a 'f' or 'F' in the symbol name), we record
2863 a pointer to its type in the global in_function_type. Every
2864 time we come across a parameter symbol ('p' in its name), then
2865 this procedure adds the name and type of that parameter
2866 to the function type pointed to by *TYPE. (Which should correspond
2867 to in_function_type if it was called correctly).
2869 Note that since we are modifying a type, the result of
2870 lookup_function_type() should be bcopy()ed before calling
2871 this. When not in strict typing mode, the expression
2872 evaluator can choose to ignore this.
2874 Assumption: All of a function's parameter symbols will
2875 appear before another function symbol is found. The parameters
2876 appear in the same order in the argument list as they do in the
2880 add_param_to_type (type
,sym
)
2884 int num
= ++(TYPE_NFIELDS(*type
));
2886 if(TYPE_NFIELDS(*type
)-1)
2887 TYPE_FIELDS(*type
) =
2888 (struct field
*)xrealloc((char *)(TYPE_FIELDS(*type
)),
2889 num
*sizeof(struct field
));
2891 TYPE_FIELDS(*type
) =
2892 (struct field
*)xmalloc(num
*sizeof(struct field
));
2894 TYPE_FIELD_BITPOS(*type
,num
-1) = num
-1;
2895 TYPE_FIELD_BITSIZE(*type
,num
-1) = 0;
2896 TYPE_FIELD_TYPE(*type
,num
-1) = SYMBOL_TYPE(sym
);
2897 TYPE_FIELD_NAME(*type
,num
-1) = SYMBOL_NAME(sym
);
2902 _initialize_symtab ()
2904 add_info ("variables", variables_info
,
2905 "All global and static variable names, or those matching REGEXP.");
2906 add_info ("functions", functions_info
,
2907 "All function names, or those matching REGEXP.");
2909 /* FIXME: This command has at least the following problems:
2910 1. It prints builtin types (in a very strange and confusing fashion).
2911 2. It doesn't print right, e.g. with
2912 typedef struct foo *FOO
2913 type_print prints "FOO" when we want to make it (in this situation)
2914 print "struct foo *".
2915 I also think "ptype" or "whatis" is more likely to be useful (but if
2916 there is much disagreement "info types" can be fixed). */
2917 add_info ("types", types_info
,
2918 "All type names, or those matching REGEXP.");
2921 add_info ("methods", methods_info
,
2922 "All method names, or those matching REGEXP::REGEXP.\n\
2923 If the class qualifier is ommited, it is assumed to be the current scope.\n\
2924 If the first REGEXP is ommited, then all methods matching the second REGEXP\n\
2927 add_info ("sources", sources_info
,
2928 "Source files in the program.");
2930 add_com ("rbreak", no_class
, rbreak_command
,
2931 "Set a breakpoint for all functions matching REGEXP.");
2933 /* Initialize the one built-in type that isn't language dependent... */
2934 builtin_type_error
= init_type (TYPE_CODE_ERROR
, 0, 0, "<unknown type>");