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. */
36 #include <sys/types.h>
41 extern char *getenv ();
43 extern char *cplus_demangle ();
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 fatal ("Internal: readin pst found when no symtab found.");
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 fatal ("Internal: readin pst found when no symtab found.");
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
);
172 switch (TYPE_CODE (type
))
174 case TYPE_CODE_STRUCT
:
176 case TYPE_CODE_UNION
:
183 name
= strchr (name
, ' ');
187 return TYPE_NAME (type
);
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_typename (type
)
230 static struct type
*last_type
;
231 static char *mangled_typename
;
233 if (type
!= last_type
)
235 /* Need a new type prefix. */
237 char *newname
= type_name_no_tag (type
);
241 if (mangled_typename
)
242 free (mangled_typename
);
244 len
= strlen (newname
);
245 sprintf (buf
, "__%d", len
);
246 mangled_typename
= (char *)xmalloc (strlen (buf
) + len
+ 1);
247 strcpy (mangled_typename
, buf
);
248 strcat (mangled_typename
, newname
);
249 /* Now we have built "__#newname". */
251 return mangled_typename
;
254 /* Lookup a primitive type named NAME.
255 Return zero if NAME is not a primitive type.*/
258 lookup_primitive_typename (name
)
261 struct type
** const *p
;
263 for (p
= current_language
->la_builtin_type_vector
; *p
; p
++)
264 if(!strcmp((**p
)->name
, name
))
269 /* Lookup a typedef or primitive type named NAME,
270 visible in lexical block BLOCK.
271 If NOERR is nonzero, return zero if NAME is not suitably defined. */
274 lookup_typename (name
, block
, noerr
)
279 register struct symbol
*sym
=
280 lookup_symbol (name
, block
, VAR_NAMESPACE
, 0, (struct symtab
**)NULL
);
281 if (sym
== 0 || SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
284 tmp
= lookup_primitive_typename (name
);
287 else if (!tmp
&& noerr
)
290 error ("No type named %s.", name
);
292 return SYMBOL_TYPE (sym
);
296 lookup_unsigned_typename (name
)
299 char *uns
= alloca (strlen(name
) + 10);
301 strcpy (uns
, "unsigned ");
302 strcpy (uns
+9, name
);
303 return lookup_typename (uns
, (struct block
*)0, 0);
306 /* Lookup a structure type named "struct NAME",
307 visible in lexical block BLOCK. */
310 lookup_struct (name
, block
)
314 register struct symbol
*sym
315 = lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0, (struct symtab
**)NULL
);
318 error ("No struct type named %s.", name
);
319 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
320 error ("This context has class, union or enum %s, not a struct.", name
);
321 return SYMBOL_TYPE (sym
);
324 /* Lookup a union type named "union NAME",
325 visible in lexical block BLOCK. */
328 lookup_union (name
, block
)
332 register struct symbol
*sym
333 = lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0, (struct symtab
**)NULL
);
336 error ("No union type named %s.", name
);
337 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_UNION
)
338 error ("This context has class, struct or enum %s, not a union.", name
);
339 return SYMBOL_TYPE (sym
);
342 /* Lookup an enum type named "enum NAME",
343 visible in lexical block BLOCK. */
346 lookup_enum (name
, block
)
350 register struct symbol
*sym
351 = lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0, (struct symtab
**)NULL
);
353 error ("No enum type named %s.", name
);
354 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_ENUM
)
355 error ("This context has class, struct or union %s, not an enum.", name
);
356 return SYMBOL_TYPE (sym
);
359 /* Given a type TYPE, lookup the type of the component of type named
361 If NOERR is nonzero, return zero if NAME is not suitably defined. */
364 lookup_struct_elt_type (type
, name
, noerr
)
371 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
372 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
374 target_terminal_ours ();
376 fprintf (stderr
, "Type ");
377 type_print (type
, "", stderr
, -1);
378 error (" is not a structure or union type.");
381 check_stub_type (type
);
383 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
385 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
387 if (t_field_name
&& !strcmp (t_field_name
, name
))
388 return TYPE_FIELD_TYPE (type
, i
);
390 /* OK, it's not in this class. Recursively check the baseclasses. */
391 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
393 struct type
*t
= lookup_struct_elt_type (TYPE_BASECLASS (type
, i
),
402 target_terminal_ours ();
404 fprintf (stderr
, "Type ");
405 type_print (type
, "", stderr
, -1);
406 fprintf (stderr
, " has no component named ");
407 fputs_filtered (name
, stderr
);
409 return (struct type
*)-1; /* For lint */
412 /* Given a type TYPE, return a type of pointers to that type.
413 May need to construct such a type if this is the first use.
415 C++: use TYPE_MAIN_VARIANT and TYPE_CHAIN to keep pointer
416 to member types under control. */
419 lookup_pointer_type (type
)
422 register struct type
*ptype
= TYPE_POINTER_TYPE (type
);
423 if (ptype
) return TYPE_MAIN_VARIANT (ptype
);
425 /* This is the first time anyone wanted a pointer to a TYPE. */
426 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
427 ptype
= (struct type
*) xmalloc (sizeof (struct type
));
429 ptype
= (struct type
*) obstack_alloc (symbol_obstack
,
430 sizeof (struct type
));
432 bzero (ptype
, sizeof (struct type
));
433 TYPE_MAIN_VARIANT (ptype
) = ptype
;
434 TYPE_TARGET_TYPE (ptype
) = type
;
435 TYPE_POINTER_TYPE (type
) = ptype
;
436 /* New type is permanent if type pointed to is permanent. */
437 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
438 TYPE_FLAGS (ptype
) |= TYPE_FLAG_PERM
;
439 /* We assume the machine has only one representation for pointers! */
440 /* FIXME: This confuses host<->target data representations, and is a
441 poor assumption besides. */
442 TYPE_LENGTH (ptype
) = sizeof (char *);
443 TYPE_CODE (ptype
) = TYPE_CODE_PTR
;
448 lookup_reference_type (type
)
451 register struct type
*rtype
= TYPE_REFERENCE_TYPE (type
);
452 if (rtype
) return TYPE_MAIN_VARIANT (rtype
);
454 /* This is the first time anyone wanted a pointer to a TYPE. */
455 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
456 rtype
= (struct type
*) xmalloc (sizeof (struct type
));
458 rtype
= (struct type
*) obstack_alloc (symbol_obstack
,
459 sizeof (struct type
));
461 bzero (rtype
, sizeof (struct type
));
462 TYPE_MAIN_VARIANT (rtype
) = rtype
;
463 TYPE_TARGET_TYPE (rtype
) = type
;
464 TYPE_REFERENCE_TYPE (type
) = rtype
;
465 /* New type is permanent if type pointed to is permanent. */
466 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
467 TYPE_FLAGS (rtype
) |= TYPE_FLAG_PERM
;
468 /* We assume the machine has only one representation for pointers! */
469 TYPE_LENGTH (rtype
) = sizeof (char *);
470 TYPE_CODE (rtype
) = TYPE_CODE_REF
;
475 /* Implement direct support for MEMBER_TYPE in GNU C++.
476 May need to construct such a type if this is the first use.
477 The TYPE is the type of the member. The DOMAIN is the type
478 of the aggregate that the member belongs to. */
481 lookup_member_type (type
, domain
)
482 struct type
*type
, *domain
;
484 register struct type
*mtype
= TYPE_MAIN_VARIANT (type
);
485 struct type
*main_type
;
490 if (TYPE_DOMAIN_TYPE (mtype
) == domain
)
492 mtype
= TYPE_NEXT_VARIANT (mtype
);
495 /* This is the first time anyone wanted this member type. */
496 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
497 mtype
= (struct type
*) xmalloc (sizeof (struct type
));
499 mtype
= (struct type
*) obstack_alloc (symbol_obstack
,
500 sizeof (struct type
));
502 bzero (mtype
, sizeof (struct type
));
507 TYPE_NEXT_VARIANT (mtype
) = TYPE_NEXT_VARIANT (main_type
);
508 TYPE_NEXT_VARIANT (main_type
) = mtype
;
510 TYPE_MAIN_VARIANT (mtype
) = main_type
;
511 TYPE_TARGET_TYPE (mtype
) = type
;
512 TYPE_DOMAIN_TYPE (mtype
) = domain
;
513 /* New type is permanent if type pointed to is permanent. */
514 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
515 TYPE_FLAGS (mtype
) |= TYPE_FLAG_PERM
;
517 /* In practice, this is never used. */
518 TYPE_LENGTH (mtype
) = 1;
519 TYPE_CODE (mtype
) = TYPE_CODE_MEMBER
;
522 /* Now splice in the new member pointer type. */
525 /* This type was not "smashed". */
526 TYPE_CHAIN (mtype
) = TYPE_CHAIN (main_type
);
527 TYPE_CHAIN (main_type
) = mtype
;
534 /* Allocate a stub method whose return type is
535 TYPE. We will fill in arguments later. This always
536 returns a fresh type. If we unify this type with
537 an existing type later, the storage allocated
538 here can be freed. */
540 allocate_stub_method (type
)
543 struct type
*mtype
= (struct type
*)xmalloc (sizeof (struct type
));
544 bzero (mtype
, sizeof (struct type
));
545 TYPE_MAIN_VARIANT (mtype
) = mtype
;
546 TYPE_TARGET_TYPE (mtype
) = type
;
547 TYPE_FLAGS (mtype
) = TYPE_FLAG_STUB
;
548 TYPE_CODE (mtype
) = TYPE_CODE_METHOD
;
549 TYPE_LENGTH (mtype
) = 1;
553 /* Lookup a method type belonging to class DOMAIN, returning type TYPE,
554 and taking a list of arguments ARGS.
555 If one is not found, allocate a new one. */
558 lookup_method_type (domain
, type
, args
)
559 struct type
*domain
, *type
, **args
;
561 register struct type
*mtype
= TYPE_MAIN_VARIANT (type
);
562 struct type
*main_type
;
567 if (TYPE_DOMAIN_TYPE (mtype
) == domain
)
569 struct type
**t1
= args
;
570 struct type
**t2
= TYPE_ARG_TYPES (mtype
);
574 for (i
= 0; t1
[i
] != 0 && t1
[i
]->code
!= TYPE_CODE_VOID
; i
++)
581 mtype
= TYPE_NEXT_VARIANT (mtype
);
584 /* This is the first time anyone wanted this member type. */
585 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
586 mtype
= (struct type
*) xmalloc (sizeof (struct type
));
588 mtype
= (struct type
*) obstack_alloc (symbol_obstack
,
589 sizeof (struct type
));
591 bzero (mtype
, sizeof (struct type
));
596 TYPE_NEXT_VARIANT (mtype
) = TYPE_NEXT_VARIANT (main_type
);
597 TYPE_NEXT_VARIANT (main_type
) = mtype
;
599 TYPE_MAIN_VARIANT (mtype
) = main_type
;
600 TYPE_TARGET_TYPE (mtype
) = type
;
601 TYPE_DOMAIN_TYPE (mtype
) = domain
;
602 TYPE_ARG_TYPES (mtype
) = args
;
603 /* New type is permanent if type pointed to is permanent. */
604 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
605 TYPE_FLAGS (mtype
) |= TYPE_FLAG_PERM
;
607 /* In practice, this is never used. */
608 TYPE_LENGTH (mtype
) = 1;
609 TYPE_CODE (mtype
) = TYPE_CODE_METHOD
;
612 /* Now splice in the new member pointer type. */
615 /* This type was not "smashed". */
616 TYPE_CHAIN (mtype
) = TYPE_CHAIN (main_type
);
617 TYPE_CHAIN (main_type
) = mtype
;
625 /* Given a type TYPE, return a type which has offset OFFSET,
626 via_virtual VIA_VIRTUAL, and via_public VIA_PUBLIC.
627 May need to construct such a type if none exists. */
629 lookup_basetype_type (type
, offset
, via_virtual
, via_public
)
632 int via_virtual
, via_public
;
634 register struct type
*btype
= TYPE_MAIN_VARIANT (type
);
635 struct type
*main_type
;
639 printf ("Internal error: type offset non-zero in lookup_basetype_type");
646 if (/* TYPE_OFFSET (btype) == offset
647 && */ TYPE_VIA_PUBLIC (btype
) == via_public
648 && TYPE_VIA_VIRTUAL (btype
) == via_virtual
)
650 btype
= TYPE_NEXT_VARIANT (btype
);
653 /* This is the first time anyone wanted this member type. */
654 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
655 btype
= (struct type
*) xmalloc (sizeof (struct type
));
657 btype
= (struct type
*) obstack_alloc (symbol_obstack
,
658 sizeof (struct type
));
663 bzero (btype
, sizeof (struct type
));
664 TYPE_MAIN_VARIANT (btype
) = main_type
;
668 bcopy (main_type
, btype
, sizeof (struct type
));
669 TYPE_NEXT_VARIANT (main_type
) = btype
;
671 /* TYPE_OFFSET (btype) = offset; */
673 TYPE_FLAGS (btype
) |= TYPE_FLAG_VIA_PUBLIC
;
675 TYPE_FLAGS (btype
) |= TYPE_FLAG_VIA_VIRTUAL
;
676 /* New type is permanent if type pointed to is permanent. */
677 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
678 TYPE_FLAGS (btype
) |= TYPE_FLAG_PERM
;
680 /* In practice, this is never used. */
681 TYPE_LENGTH (btype
) = 1;
682 TYPE_CODE (btype
) = TYPE_CODE_STRUCT
;
688 /* Given a type TYPE, return a type of functions that return that type.
689 May need to construct such a type if this is the first use. */
692 lookup_function_type (type
)
695 register struct type
*ptype
= TYPE_FUNCTION_TYPE (type
);
696 if (ptype
) return ptype
;
698 /* This is the first time anyone wanted a function returning a TYPE. */
699 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
700 ptype
= (struct type
*) xmalloc (sizeof (struct type
));
702 ptype
= (struct type
*) obstack_alloc (symbol_obstack
,
703 sizeof (struct type
));
705 bzero (ptype
, sizeof (struct type
));
706 TYPE_TARGET_TYPE (ptype
) = type
;
707 TYPE_FUNCTION_TYPE (type
) = ptype
;
708 /* New type is permanent if type returned is permanent. */
709 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
710 TYPE_FLAGS (ptype
) |= TYPE_FLAG_PERM
;
711 TYPE_LENGTH (ptype
) = 1;
712 TYPE_CODE (ptype
) = TYPE_CODE_FUNC
;
713 TYPE_NFIELDS (ptype
) = 0;
717 /* Create an array type. Elements will be of type TYPE, and there will
720 Eventually this should be extended to take two more arguments which
721 specify the bounds of the array and the type of the index.
722 It should also be changed to be a "lookup" function, with the
723 appropriate data structures added to the type field.
724 Then read array type should call here. */
727 create_array_type (element_type
, number
)
728 struct type
*element_type
;
731 struct type
*result_type
= (struct type
*)
732 obstack_alloc (symbol_obstack
, sizeof (struct type
));
733 struct type
*range_type
;
735 bzero (result_type
, sizeof (struct type
));
737 TYPE_CODE (result_type
) = TYPE_CODE_ARRAY
;
738 TYPE_TARGET_TYPE (result_type
) = element_type
;
739 TYPE_LENGTH (result_type
) = number
* TYPE_LENGTH (element_type
);
740 TYPE_NFIELDS (result_type
) = 1;
741 TYPE_FIELDS (result_type
) =
742 (struct field
*) obstack_alloc (symbol_obstack
, sizeof (struct field
));
745 /* Create range type. */
746 range_type
= (struct type
*) obstack_alloc (symbol_obstack
,
747 sizeof (struct type
));
748 TYPE_CODE (range_type
) = TYPE_CODE_RANGE
;
749 TYPE_TARGET_TYPE (range_type
) = builtin_type_int
; /* FIXME */
751 /* This should never be needed. */
752 TYPE_LENGTH (range_type
) = sizeof (int);
754 TYPE_NFIELDS (range_type
) = 2;
755 TYPE_FIELDS (range_type
) =
756 (struct field
*) obstack_alloc (symbol_obstack
,
757 2 * sizeof (struct field
));
758 TYPE_FIELD_BITPOS (range_type
, 0) = 0; /* FIXME */
759 TYPE_FIELD_BITPOS (range_type
, 1) = number
-1; /* FIXME */
760 TYPE_FIELD_TYPE (range_type
, 0) = builtin_type_int
; /* FIXME */
761 TYPE_FIELD_TYPE (range_type
, 1) = builtin_type_int
; /* FIXME */
763 TYPE_FIELD_TYPE(result_type
,0)=range_type
;
764 TYPE_VPTR_FIELDNO (result_type
) = -1;
770 /* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE. */
773 smash_to_member_type (type
, domain
, to_type
)
774 struct type
*type
, *domain
, *to_type
;
776 bzero (type
, sizeof (struct type
));
777 TYPE_TARGET_TYPE (type
) = to_type
;
778 TYPE_DOMAIN_TYPE (type
) = domain
;
780 /* In practice, this is never needed. */
781 TYPE_LENGTH (type
) = 1;
782 TYPE_CODE (type
) = TYPE_CODE_MEMBER
;
784 TYPE_MAIN_VARIANT (type
) = lookup_member_type (domain
, to_type
);
787 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE. */
790 smash_to_method_type (type
, domain
, to_type
, args
)
791 struct type
*type
, *domain
, *to_type
, **args
;
793 bzero (type
, sizeof (struct type
));
794 TYPE_TARGET_TYPE (type
) = to_type
;
795 TYPE_DOMAIN_TYPE (type
) = domain
;
796 TYPE_ARG_TYPES (type
) = args
;
798 /* In practice, this is never needed. */
799 TYPE_LENGTH (type
) = 1;
800 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
802 TYPE_MAIN_VARIANT (type
) = lookup_method_type (domain
, to_type
, args
);
805 /* Find which partial symtab on the partial_symtab_list contains
806 PC. Return 0 if none. */
808 struct partial_symtab
*
810 register CORE_ADDR pc
;
812 register struct partial_symtab
*ps
;
814 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
815 if (pc
>= ps
->textlow
&& pc
< ps
->texthigh
)
821 /* Find which partial symbol within a psymtab contains PC. Return 0
822 if none. Check all psymtabs if PSYMTAB is 0. */
823 struct partial_symbol
*
824 find_pc_psymbol (psymtab
, pc
)
825 struct partial_symtab
*psymtab
;
828 struct partial_symbol
*best
, *p
;
832 psymtab
= find_pc_psymtab (pc
);
836 best_pc
= psymtab
->textlow
- 1;
838 for (p
= static_psymbols
.list
+ psymtab
->statics_offset
;
839 (p
- (static_psymbols
.list
+ psymtab
->statics_offset
)
840 < psymtab
->n_static_syms
);
842 if (SYMBOL_NAMESPACE (p
) == VAR_NAMESPACE
843 && SYMBOL_CLASS (p
) == LOC_BLOCK
844 && pc
>= SYMBOL_VALUE_ADDRESS (p
)
845 && SYMBOL_VALUE_ADDRESS (p
) > best_pc
)
847 best_pc
= SYMBOL_VALUE_ADDRESS (p
);
850 if (best_pc
== psymtab
->textlow
- 1)
856 /* Find the definition for a specified symbol name NAME
857 in namespace NAMESPACE, visible from lexical block BLOCK.
858 Returns the struct symbol pointer, or zero if no symbol is found.
859 If SYMTAB is non-NULL, store the symbol table in which the
860 symbol was found there, or NULL if not found.
861 C++: if IS_A_FIELD_OF_THIS is nonzero on entry, check to see if
862 NAME is a field of the current implied argument `this'. If so set
863 *IS_A_FIELD_OF_THIS to 1, otherwise set it to zero.
864 BLOCK_FOUND is set to the block in which NAME is found (in the case of
865 a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */
868 lookup_symbol (name
, block
, namespace, is_a_field_of_this
, symtab
)
870 register struct block
*block
;
871 enum namespace namespace;
872 int *is_a_field_of_this
;
873 struct symtab
**symtab
;
875 register struct symbol
*sym
;
876 register struct symtab
*s
;
877 register struct partial_symtab
*ps
;
878 struct blockvector
*bv
;
880 /* Search specified block and its superiors. */
884 sym
= lookup_block_symbol (block
, name
, namespace);
890 /* Search the list of symtabs for one which contains the
891 address of the start of this block. */
893 for (s
= symtab_list
; s
; s
= s
->next
)
895 bv
= BLOCKVECTOR (s
);
896 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
897 if (BLOCK_START (b
) <= BLOCK_START (block
)
898 && BLOCK_END (b
) > BLOCK_START (block
))
906 block
= BLOCK_SUPERBLOCK (block
);
909 /* But that doesn't do any demangling for the STATIC_BLOCK.
910 I'm not sure whether demangling is needed in the case of
911 nested function in inner blocks; if so this needs to be changed.
913 Don't need to mess with the psymtabs; if we have a block,
914 that file is read in. If we don't, then we deal later with
915 all the psymtab stuff that needs checking. */
916 if (namespace == VAR_NAMESPACE
&& block
!= NULL
)
919 /* Find the right symtab. */
920 for (s
= symtab_list
; s
; s
= s
->next
)
922 bv
= BLOCKVECTOR (s
);
923 b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
924 if (BLOCK_START (b
) <= BLOCK_START (block
)
925 && BLOCK_END (b
) > BLOCK_START (block
))
927 sym
= lookup_demangled_block_symbol (b
, name
);
940 /* C++: If requested to do so by the caller,
941 check to see if NAME is a field of `this'. */
942 if (is_a_field_of_this
)
944 struct value
*v
= value_of_this (0);
946 *is_a_field_of_this
= 0;
947 if (v
&& check_field (v
, name
))
949 *is_a_field_of_this
= 1;
956 /* Now search all global blocks. Do the symtab's first, then
957 check the psymtab's */
959 for (s
= symtab_list
; s
; s
= s
->next
)
961 bv
= BLOCKVECTOR (s
);
962 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
963 sym
= lookup_block_symbol (block
, name
, namespace);
973 /* Check for the possibility of the symbol being a global function
974 that is stored on the misc function vector. Eventually, all
975 global symbols might be resolved in this way. */
977 if (namespace == VAR_NAMESPACE
)
979 int ind
= lookup_misc_func (name
);
981 /* Look for a mangled C++ name for NAME. */
984 int name_len
= strlen (name
);
986 for (ind
= misc_function_count
; --ind
>= 0; )
987 /* Assume orginal name is prefix of mangled name. */
988 if (!strncmp (misc_function_vector
[ind
].name
, name
, name_len
))
991 cplus_demangle(misc_function_vector
[ind
].name
, -1);
992 if (demangled
!= NULL
)
994 int cond
= strcmp (demangled
, name
);
1000 /* Loop terminates on no match with ind == -1. */
1005 s
= find_pc_symtab (misc_function_vector
[ind
].address
);
1006 /* If S is zero, there are no debug symbols for this file.
1007 Skip this stuff and check for matching static symbols below. */
1010 bv
= BLOCKVECTOR (s
);
1011 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1012 sym
= lookup_block_symbol (block
, misc_function_vector
[ind
].name
,
1014 /* sym == 0 if symbol was found in the misc_function_vector
1015 but not in the symtab.
1016 Return 0 to use the misc_function definition of "foo_".
1018 This happens for Fortran "foo_" symbols,
1019 which are "foo" in the symtab.
1021 This can also happen if "asm" is used to make a
1022 regular symbol but not a debugging symbol, e.g.
1023 asm(".globl _main");
1034 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
1035 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 1, namespace))
1037 s
= PSYMTAB_TO_SYMTAB(ps
);
1038 bv
= BLOCKVECTOR (s
);
1039 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1040 sym
= lookup_block_symbol (block
, name
, namespace);
1042 fatal ("Internal: global symbol found in psymtab but not in symtab");
1048 /* Now search all per-file blocks.
1049 Not strictly correct, but more useful than an error.
1050 Do the symtabs first, then check the psymtabs */
1052 for (s
= symtab_list
; s
; s
= s
->next
)
1054 bv
= BLOCKVECTOR (s
);
1055 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1056 sym
= lookup_block_symbol (block
, name
, namespace);
1059 block_found
= block
;
1066 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
1067 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 0, namespace))
1069 s
= PSYMTAB_TO_SYMTAB(ps
);
1070 bv
= BLOCKVECTOR (s
);
1071 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1072 sym
= lookup_block_symbol (block
, name
, namespace);
1074 fatal ("Internal: static symbol found in psymtab but not in symtab");
1080 /* Now search all per-file blocks for static mangled symbols.
1081 Do the symtabs first, then check the psymtabs. */
1083 if (namespace == VAR_NAMESPACE
)
1085 for (s
= symtab_list
; s
; s
= s
->next
)
1087 bv
= BLOCKVECTOR (s
);
1088 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1089 sym
= lookup_demangled_block_symbol (block
, name
);
1092 block_found
= block
;
1099 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
1100 if (!ps
->readin
&& lookup_demangled_partial_symbol (ps
, name
))
1102 s
= PSYMTAB_TO_SYMTAB(ps
);
1103 bv
= BLOCKVECTOR (s
);
1104 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1105 sym
= lookup_demangled_block_symbol (block
, name
);
1107 fatal ("Internal: static symbol found in psymtab but not in symtab");
1119 /* Look for a static demangled symbol in block BLOCK. */
1121 static struct symbol
*
1122 lookup_demangled_block_symbol (block
, name
)
1123 register struct block
*block
;
1126 register int bot
, top
, inc
;
1127 register struct symbol
*sym
;
1130 top
= BLOCK_NSYMS (block
);
1135 sym
= BLOCK_SYM (block
, bot
);
1136 if (SYMBOL_NAME (sym
)[0] == inc
1137 && SYMBOL_NAMESPACE (sym
) == VAR_NAMESPACE
)
1139 char *demangled
= cplus_demangle(SYMBOL_NAME (sym
), -1);
1140 if (demangled
!= NULL
)
1142 int cond
= strcmp (demangled
, name
);
1154 /* Look, in partial_symtab PST, for static mangled symbol NAME. */
1156 static struct partial_symbol
*
1157 lookup_demangled_partial_symbol (pst
, name
)
1158 struct partial_symtab
*pst
;
1161 struct partial_symbol
*start
, *psym
;
1162 int length
= pst
->n_static_syms
;
1163 register int inc
= name
[0];
1166 return (struct partial_symbol
*) 0;
1168 start
= static_psymbols
.list
+ pst
->statics_offset
;
1169 for (psym
= start
; psym
< start
+ length
; psym
++)
1171 if (SYMBOL_NAME (psym
)[0] == inc
1172 && SYMBOL_NAMESPACE (psym
) == VAR_NAMESPACE
)
1174 char *demangled
= cplus_demangle(SYMBOL_NAME (psym
), -1);
1175 if (demangled
!= NULL
)
1177 int cond
= strcmp (demangled
, name
);
1185 return (struct partial_symbol
*) 0;
1188 /* Look, in partial_symtab PST, for symbol NAME. Check the global
1189 symbols if GLOBAL, the static symbols if not */
1191 static struct partial_symbol
*
1192 lookup_partial_symbol (pst
, name
, global
, namespace)
1193 struct partial_symtab
*pst
;
1196 enum namespace namespace;
1198 struct partial_symbol
*start
, *psym
;
1199 int length
= (global
? pst
->n_global_syms
: pst
->n_static_syms
);
1202 return (struct partial_symbol
*) 0;
1205 global_psymbols
.list
+ pst
->globals_offset
:
1206 static_psymbols
.list
+ pst
->statics_offset
);
1208 if (global
) /* This means we can use a binary */
1211 struct partial_symbol
*top
, *bottom
, *center
;
1213 /* Binary search. This search is guaranteed to end with center
1214 pointing at the earliest partial symbol with the correct
1215 name. At that point *all* partial symbols with that name
1216 will be checked against the correct namespace. */
1218 top
= start
+ length
- 1;
1219 while (top
> bottom
)
1221 center
= bottom
+ (top
- bottom
) / 2;
1223 assert (center
< top
);
1225 if (strcmp (SYMBOL_NAME (center
), name
) >= 0)
1228 bottom
= center
+ 1;
1230 assert (top
== bottom
);
1232 while (!strcmp (SYMBOL_NAME (top
), name
))
1234 if (SYMBOL_NAMESPACE (top
) == namespace)
1241 /* Can't use a binary search */
1242 for (psym
= start
; psym
< start
+ length
; psym
++)
1243 if (namespace == SYMBOL_NAMESPACE (psym
)
1244 && !strcmp (name
, SYMBOL_NAME (psym
)))
1248 return (struct partial_symbol
*) 0;
1251 /* Look for a symbol in block BLOCK. */
1254 lookup_block_symbol (block
, name
, namespace)
1255 register struct block
*block
;
1257 enum namespace namespace;
1259 register int bot
, top
, inc
;
1260 register struct symbol
*sym
, *parameter_sym
;
1262 top
= BLOCK_NSYMS (block
);
1265 /* If the blocks's symbols were sorted, start with a binary search. */
1267 if (BLOCK_SHOULD_SORT (block
))
1269 /* First, advance BOT to not far before
1270 the first symbol whose name is NAME. */
1274 inc
= (top
- bot
+ 1);
1275 /* No need to keep binary searching for the last few bits worth. */
1278 inc
= (inc
>> 1) + bot
;
1279 sym
= BLOCK_SYM (block
, inc
);
1280 if (SYMBOL_NAME (sym
)[0] < name
[0])
1282 else if (SYMBOL_NAME (sym
)[0] > name
[0])
1284 else if (strcmp (SYMBOL_NAME (sym
), name
) < 0)
1290 /* Now scan forward until we run out of symbols,
1291 find one whose name is greater than NAME,
1292 or find one we want.
1293 If there is more than one symbol with the right name and namespace,
1294 we return the first one. dbxread.c is careful to make sure
1295 that if one is a register then it comes first. */
1297 top
= BLOCK_NSYMS (block
);
1300 sym
= BLOCK_SYM (block
, bot
);
1301 inc
= SYMBOL_NAME (sym
)[0] - name
[0];
1303 inc
= strcmp (SYMBOL_NAME (sym
), name
);
1304 if (inc
== 0 && SYMBOL_NAMESPACE (sym
) == namespace)
1313 /* Here if block isn't sorted.
1314 This loop is equivalent to the loop above,
1315 but hacked greatly for speed.
1317 Note that parameter symbols do not always show up last in the
1318 list; this loop makes sure to take anything else other than
1319 parameter symbols first; it only uses parameter symbols as a
1320 last resort. Note that this only takes up extra computation
1323 parameter_sym
= (struct symbol
*) 0;
1324 top
= BLOCK_NSYMS (block
);
1328 sym
= BLOCK_SYM (block
, bot
);
1329 if (SYMBOL_NAME (sym
)[0] == inc
1330 && !strcmp (SYMBOL_NAME (sym
), name
)
1331 && SYMBOL_NAMESPACE (sym
) == namespace)
1333 if (SYMBOL_CLASS (sym
) == LOC_ARG
1334 || SYMBOL_CLASS (sym
) == LOC_LOCAL_ARG
1335 || SYMBOL_CLASS (sym
) == LOC_REF_ARG
1336 || SYMBOL_CLASS (sym
) == LOC_REGPARM
)
1337 parameter_sym
= sym
;
1343 return parameter_sym
; /* Will be 0 if not found. */
1346 /* Return the symbol for the function which contains a specified
1347 lexical block, described by a struct block BL. */
1353 while (BLOCK_FUNCTION (bl
) == 0 && BLOCK_SUPERBLOCK (bl
) != 0)
1354 bl
= BLOCK_SUPERBLOCK (bl
);
1356 return BLOCK_FUNCTION (bl
);
1359 /* Subroutine of find_pc_line */
1363 register CORE_ADDR pc
;
1365 register struct block
*b
;
1366 struct blockvector
*bv
;
1367 register struct symtab
*s
;
1368 register struct partial_symtab
*ps
;
1370 /* Search all symtabs for one whose file contains our pc */
1372 for (s
= symtab_list
; s
; s
= s
->next
)
1374 bv
= BLOCKVECTOR (s
);
1375 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1376 if (BLOCK_START (b
) <= pc
1377 && BLOCK_END (b
) > pc
)
1383 ps
= find_pc_psymtab (pc
);
1384 if (ps
&& ps
->readin
)
1386 "(Internal error: pc in read in psymtab, but not in symtab.)\n");
1389 s
= PSYMTAB_TO_SYMTAB (ps
);
1395 /* Find the source file and line number for a given PC value.
1396 Return a structure containing a symtab pointer, a line number,
1397 and a pc range for the entire source line.
1398 The value's .pc field is NOT the specified pc.
1399 NOTCURRENT nonzero means, if specified pc is on a line boundary,
1400 use the line that ends there. Otherwise, in that case, the line
1401 that begins there is used. */
1403 struct symtab_and_line
1404 find_pc_line (pc
, notcurrent
)
1409 register struct linetable
*l
;
1412 register struct linetable_entry
*item
;
1413 struct symtab_and_line val
;
1414 struct blockvector
*bv
;
1416 /* Info on best line seen so far, and where it starts, and its file. */
1419 CORE_ADDR best_pc
= 0;
1420 CORE_ADDR best_end
= 0;
1421 struct symtab
*best_symtab
= 0;
1423 /* Store here the first line number
1424 of a file which contains the line at the smallest pc after PC.
1425 If we don't find a line whose range contains PC,
1426 we will use a line one less than this,
1427 with a range from the start of that file to the first line's pc. */
1429 CORE_ADDR alt_pc
= 0;
1430 struct symtab
*alt_symtab
= 0;
1432 /* Info on best line seen in this file. */
1437 /* Info on first line of this file. */
1442 /* If this pc is not from the current frame,
1443 it is the address of the end of a call instruction.
1444 Quite likely that is the start of the following statement.
1445 But what we want is the statement containing the instruction.
1446 Fudge the pc to make sure we get that. */
1448 if (notcurrent
) pc
-= 1;
1450 s
= find_pc_symtab (pc
);
1460 bv
= BLOCKVECTOR (s
);
1462 /* Look at all the symtabs that share this blockvector.
1463 They all have the same apriori range, that we found was right;
1464 but they have different line tables. */
1466 for (; s
&& BLOCKVECTOR (s
) == bv
; s
= s
->next
)
1468 /* Find the best line in this symtab. */
1473 for (i
= 0; i
< len
; i
++)
1475 item
= &(l
->item
[i
]);
1479 first_line
= item
->line
;
1480 first_pc
= item
->pc
;
1482 /* Return the last line that did not start after PC. */
1485 prev_line
= item
->line
;
1492 /* Is this file's best line closer than the best in the other files?
1493 If so, record this file, and its best line, as best so far. */
1494 if (prev_line
>= 0 && prev_pc
> best_pc
)
1497 best_line
= prev_line
;
1500 best_end
= item
->pc
;
1504 /* Is this file's first line closer than the first lines of other files?
1505 If so, record this file, and its first line, as best alternate. */
1506 if (first_line
>= 0 && first_pc
> pc
1507 && (alt_pc
== 0 || first_pc
< alt_pc
))
1510 alt_line
= first_line
;
1514 if (best_symtab
== 0)
1516 val
.symtab
= alt_symtab
;
1517 val
.line
= alt_line
- 1;
1518 val
.pc
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
1523 val
.symtab
= best_symtab
;
1524 val
.line
= best_line
;
1526 val
.end
= (best_end
? best_end
1528 : BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
))));
1533 /* Find the PC value for a given source file and line number.
1534 Returns zero for invalid line number.
1535 The source file is specified with a struct symtab. */
1538 find_line_pc (symtab
, line
)
1539 struct symtab
*symtab
;
1542 register struct linetable
*l
;
1548 l
= LINETABLE (symtab
);
1549 ind
= find_line_common(l
, line
, &dummy
);
1550 return (ind
>= 0) ? l
->item
[ind
].pc
: 0;
1553 /* Find the range of pc values in a line.
1554 Store the starting pc of the line into *STARTPTR
1555 and the ending pc (start of next line) into *ENDPTR.
1556 Returns 1 to indicate success.
1557 Returns 0 if could not find the specified line. */
1560 find_line_pc_range (symtab
, thisline
, startptr
, endptr
)
1561 struct symtab
*symtab
;
1563 CORE_ADDR
*startptr
, *endptr
;
1565 register struct linetable
*l
;
1567 int exact_match
; /* did we get an exact linenumber match */
1572 l
= LINETABLE (symtab
);
1573 ind
= find_line_common (l
, thisline
, &exact_match
);
1576 *startptr
= l
->item
[ind
].pc
;
1577 /* If we have not seen an entry for the specified line,
1578 assume that means the specified line has zero bytes. */
1579 if (!exact_match
|| ind
== l
->nitems
-1)
1580 *endptr
= *startptr
;
1582 /* Perhaps the following entry is for the following line.
1583 It's worth a try. */
1584 if (ind
+1 < l
->nitems
1585 && l
->item
[ind
+1].line
== thisline
+ 1)
1586 *endptr
= l
->item
[ind
+1].pc
;
1588 *endptr
= find_line_pc (symtab
, thisline
+1);
1595 /* Given a line table and a line number, return the index into the line
1596 table for the pc of the nearest line whose number is >= the specified one.
1597 Return -1 if none is found. The value is >= 0 if it is an index.
1599 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
1602 find_line_common (l
, lineno
, exact_match
)
1603 register struct linetable
*l
;
1604 register int lineno
;
1610 /* BEST is the smallest linenumber > LINENO so far seen,
1611 or 0 if none has been seen so far.
1612 BEST_INDEX identifies the item for it. */
1614 int best_index
= -1;
1621 for (i
= 0; i
< len
; i
++)
1623 register struct linetable_entry
*item
= &(l
->item
[i
]);
1625 if (item
->line
== lineno
)
1631 if (item
->line
> lineno
&& (best
== 0 || item
->line
< best
))
1638 /* If we got here, we didn't get an exact match. */
1645 find_pc_line_pc_range (pc
, startptr
, endptr
)
1647 CORE_ADDR
*startptr
, *endptr
;
1649 struct symtab_and_line sal
;
1650 sal
= find_pc_line (pc
, 0);
1653 return sal
.symtab
!= 0;
1656 /* If P is of the form "operator[ \t]+..." where `...' is
1657 some legitimate operator text, return a pointer to the
1658 beginning of the substring of the operator text.
1659 Otherwise, return "". */
1661 operator_chars (p
, end
)
1666 if (strncmp (p
, "operator", 8))
1670 /* Don't get faked out by `operator' being part of a longer
1672 if ((*p
>= 'A' && *p
<= 'Z') || (*p
>= 'a' && *p
<= 'z')
1673 || *p
== '_' || *p
== '$' || *p
== '\0')
1676 /* Allow some whitespace between `operator' and the operator symbol. */
1677 while (*p
== ' ' || *p
== '\t')
1699 if (p
[1] == '=' || p
[1] == p
[0])
1710 error ("`operator ()' must be specified without whitespace in `()'");
1715 error ("`operator ?:' must be specified without whitespace in `?:'");
1720 error ("`operator []' must be specified without whitespace in `[]'");
1724 error ("`operator %s' not supported", p
);
1731 /* Recursive helper function for decode_line_1.
1732 * Look for methods named NAME in type T.
1733 * Return number of matches.
1734 * Put matches in PHYSNAMES and SYM_ARR (which better be big enough!).
1735 * These allocations seem to define "big enough":
1736 * sym_arr = (struct symbol **) alloca(TYPE_NFN_FIELDS_TOTAL (t) * sizeof(struct symbol*));
1737 * physnames = (char **) alloca (TYPE_NFN_FIELDS_TOTAL (t) * sizeof(char*));
1741 find_methods(t
, name
, physnames
, sym_arr
)
1745 struct symbol
**sym_arr
;
1749 struct symbol
*sym_class
;
1750 char *class_name
= type_name_no_tag (t
);
1751 /* Ignore this class if it doesn't have a name.
1752 This prevents core dumps, but is just a workaround
1753 because we might not find the function in
1754 certain cases, such as
1755 struct D {virtual int f();}
1756 struct C : D {virtual int g();}
1757 (in this case g++ 1.35.1- does not put out a name
1758 for D as such, it defines type 19 (for example) in
1759 the same stab as C, and then does a
1760 .stabs "D:T19" and a .stabs "D:t19".
1762 "break C::f" should not be looking for field f in
1764 but just for the field f in the baseclasses of C
1765 (no matter what their names).
1767 However, I don't know how to replace the code below
1768 that depends on knowing the name of D. */
1770 && (sym_class
= lookup_symbol (class_name
,
1771 (struct block
*)NULL
,
1774 (struct symtab
**)NULL
)))
1777 t
= SYMBOL_TYPE (sym_class
);
1778 for (method_counter
= TYPE_NFN_FIELDS (t
) - 1;
1779 method_counter
>= 0;
1783 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, method_counter
);
1785 char *method_name
= TYPE_FN_FIELDLIST_NAME (t
, method_counter
);
1786 if (!strcmp (name
, method_name
))
1787 /* Find all the fields with that name. */
1788 for (field_counter
= TYPE_FN_FIELDLIST_LENGTH (t
, method_counter
) - 1;
1793 if (TYPE_FLAGS (TYPE_FN_FIELD_TYPE (f
, field_counter
)) & TYPE_FLAG_STUB
)
1794 check_stub_method (t
, method_counter
, field_counter
);
1795 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, field_counter
);
1796 physnames
[i1
] = (char*) alloca (strlen (phys_name
) + 1);
1797 strcpy (physnames
[i1
], phys_name
);
1798 sym_arr
[i1
] = lookup_symbol (phys_name
,
1799 SYMBOL_BLOCK_VALUE (sym_class
),
1802 (struct symtab
**) NULL
);
1803 if (sym_arr
[i1
]) i1
++;
1807 /* Only search baseclasses if there is no match yet,
1808 * since names in derived classes override those in baseclasses.
1812 for (ibase
= 0; ibase
< TYPE_N_BASECLASSES (t
); ibase
++)
1813 i1
+= find_methods(TYPE_BASECLASS(t
, ibase
), name
,
1814 physnames
+ i1
, sym_arr
+ i1
);
1818 /* Parse a string that specifies a line number.
1819 Pass the address of a char * variable; that variable will be
1820 advanced over the characters actually parsed.
1824 LINENUM -- that line number in current file. PC returned is 0.
1825 FILE:LINENUM -- that line in that file. PC returned is 0.
1826 FUNCTION -- line number of openbrace of that function.
1827 PC returned is the start of the function.
1828 VARIABLE -- line number of definition of that variable.
1830 FILE:FUNCTION -- likewise, but prefer functions in that file.
1831 *EXPR -- line in which address EXPR appears.
1833 FUNCTION may be an undebuggable function found in misc_function_vector.
1835 If the argument FUNFIRSTLINE is nonzero, we want the first line
1836 of real code inside a function when a function is specified.
1838 DEFAULT_SYMTAB specifies the file to use if none is specified.
1839 It defaults to current_source_symtab.
1840 DEFAULT_LINE specifies the line number to use for relative
1841 line numbers (that start with signs). Defaults to current_source_line.
1843 Note that it is possible to return zero for the symtab
1844 if no file is validly specified. Callers must check that.
1845 Also, the line number returned may be invalid. */
1847 struct symtabs_and_lines
1848 decode_line_1 (argptr
, funfirstline
, default_symtab
, default_line
)
1851 struct symtab
*default_symtab
;
1854 struct symtabs_and_lines
decode_line_2 ();
1855 struct symtabs_and_lines values
;
1856 struct symtab_and_line val
;
1857 register char *p
, *p1
;
1859 register struct symtab
*s
;
1861 register struct symbol
*sym
;
1862 /* The symtab that SYM was found in. */
1863 struct symtab
*sym_symtab
;
1865 register CORE_ADDR pc
;
1868 struct symbol
*sym_class
;
1870 struct symbol
**sym_arr
;
1874 /* Defaults have defaults. */
1876 if (default_symtab
== 0)
1878 default_symtab
= current_source_symtab
;
1879 default_line
= current_source_line
;
1882 /* See if arg is *PC */
1884 if (**argptr
== '*')
1887 pc
= parse_and_eval_address_1 (argptr
);
1888 values
.sals
= (struct symtab_and_line
*)
1889 xmalloc (sizeof (struct symtab_and_line
));
1891 values
.sals
[0] = find_pc_line (pc
, 0);
1892 values
.sals
[0].pc
= pc
;
1896 /* Maybe arg is FILE : LINENUM or FILE : FUNCTION */
1900 for (p
= *argptr
; *p
; p
++)
1902 if (p
[0] == ':' || p
[0] == ' ' || p
[0] == '\t')
1905 while (p
[0] == ' ' || p
[0] == '\t') p
++;
1907 q
= operator_chars (*argptr
, &q1
);
1914 /* Extract the class name. */
1916 while (p
!= *argptr
&& p
[-1] == ' ') --p
;
1917 copy
= (char *) alloca (p
- *argptr
+ 1);
1918 bcopy (*argptr
, copy
, p
- *argptr
);
1919 copy
[p
- *argptr
] = 0;
1921 /* Discard the class name from the arg. */
1923 while (*p
== ' ' || *p
== '\t') p
++;
1926 sym_class
= lookup_symbol (copy
, 0, STRUCT_NAMESPACE
, 0,
1927 (struct symtab
**)NULL
);
1930 (TYPE_CODE (SYMBOL_TYPE (sym_class
)) == TYPE_CODE_STRUCT
1931 || TYPE_CODE (SYMBOL_TYPE (sym_class
)) == TYPE_CODE_UNION
))
1933 /* Arg token is not digits => try it as a function name
1934 Find the next token (everything up to end or next whitespace). */
1936 while (*p
&& *p
!= ' ' && *p
!= '\t' && *p
!= ',' && *p
!=':') p
++;
1937 q
= operator_chars (*argptr
, &q1
);
1939 copy
= (char *) alloca (p
- *argptr
+ 1 + (q1
- q
));
1944 copy
[2] = CPLUS_MARKER
;
1945 bcopy (q
, copy
+ 3, q1
- q
);
1946 copy
[3 + (q1
- q
)] = '\0';
1951 bcopy (*argptr
, copy
, p
- *argptr
);
1952 copy
[p
- *argptr
] = '\0';
1955 /* no line number may be specified */
1956 while (*p
== ' ' || *p
== '\t') p
++;
1960 i1
= 0; /* counter for the symbol array */
1961 t
= SYMBOL_TYPE (sym_class
);
1962 sym_arr
= (struct symbol
**) alloca(TYPE_NFN_FIELDS_TOTAL (t
) * sizeof(struct symbol
*));
1963 physnames
= (char **) alloca (TYPE_NFN_FIELDS_TOTAL (t
) * sizeof(char*));
1965 if (destructor_name_p (copy
, t
))
1967 /* destructors are a special case. */
1968 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, 0);
1969 int len
= TYPE_FN_FIELDLIST_LENGTH (t
, 0) - 1;
1970 char *phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, len
);
1971 physnames
[i1
] = (char *)alloca (strlen (phys_name
) + 1);
1972 strcpy (physnames
[i1
], phys_name
);
1974 lookup_symbol (phys_name
, SYMBOL_BLOCK_VALUE (sym_class
),
1975 VAR_NAMESPACE
, 0, (struct symtab
**)NULL
);
1976 if (sym_arr
[i1
]) i1
++;
1979 i1
= find_methods (t
, copy
, physnames
, sym_arr
);
1982 /* There is exactly one field with that name. */
1985 if (sym
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
)
1987 /* Arg is the name of a function */
1988 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) + FUNCTION_START_OFFSET
;
1991 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
1993 values
.sals
[0] = find_pc_line (pc
, 0);
1994 values
.sals
[0].pc
= (values
.sals
[0].end
&& values
.sals
[0].pc
!= pc
) ? values
.sals
[0].end
: pc
;
2004 /* There is more than one field with that name
2005 (overloaded). Ask the user which one to use. */
2006 return decode_line_2 (sym_arr
, i1
, funfirstline
);
2012 if (OPNAME_PREFIX_P (copy
))
2014 tmp
= (char *)alloca (strlen (copy
+3) + 9);
2015 strcpy (tmp
, "operator ");
2016 strcat (tmp
, copy
+3);
2020 error ("that class does not have any method named %s", tmp
);
2024 /* The quotes are important if copy is empty. */
2025 error("No class, struct, or union named \"%s\"", copy
);
2030 /* Extract the file name. */
2032 while (p
!= *argptr
&& p
[-1] == ' ') --p
;
2033 copy
= (char *) alloca (p
- *argptr
+ 1 + (q1
- q
));
2038 copy
[2] = CPLUS_MARKER
;
2039 bcopy (q
, copy
+ 3, q1
-q
);
2040 copy
[3 + (q1
-q
)] = 0;
2045 bcopy (*argptr
, copy
, p
- *argptr
);
2046 copy
[p
- *argptr
] = 0;
2049 /* Find that file's data. */
2050 s
= lookup_symtab (copy
);
2053 if (symtab_list
== 0 && partial_symtab_list
== 0)
2054 error (no_symtab_msg
);
2055 error ("No source file named %s.", copy
);
2058 /* Discard the file name from the arg. */
2060 while (*p
== ' ' || *p
== '\t') p
++;
2064 /* S is specified file's symtab, or 0 if no file specified.
2065 arg no longer contains the file name. */
2067 /* Check whether arg is all digits (and sign) */
2070 if (*p
== '-' || *p
== '+') p
++;
2071 while (*p
>= '0' && *p
<= '9')
2074 if (p
!= *argptr
&& (*p
== 0 || *p
== ' ' || *p
== '\t' || *p
== ','))
2076 /* We found a token consisting of all digits -- at least one digit. */
2077 enum sign
{none
, plus
, minus
} sign
= none
;
2079 /* This is where we need to make sure that we have good defaults.
2080 We must guarantee that this section of code is never executed
2081 when we are called with just a function name, since
2082 select_source_symtab calls us with such an argument */
2084 if (s
== 0 && default_symtab
== 0)
2086 select_source_symtab (0);
2087 default_symtab
= current_source_symtab
;
2088 default_line
= current_source_line
;
2091 if (**argptr
== '+')
2092 sign
= plus
, (*argptr
)++;
2093 else if (**argptr
== '-')
2094 sign
= minus
, (*argptr
)++;
2095 val
.line
= atoi (*argptr
);
2102 val
.line
= default_line
+ val
.line
;
2108 val
.line
= default_line
- val
.line
;
2113 break; /* No need to adjust val.line. */
2116 while (*p
== ' ' || *p
== '\t') p
++;
2122 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
2123 values
.sals
[0] = val
;
2128 /* Arg token is not digits => try it as a variable name
2129 Find the next token (everything up to end or next whitespace). */
2131 while (*p
&& *p
!= ' ' && *p
!= '\t' && *p
!= ',') p
++;
2132 copy
= (char *) alloca (p
- *argptr
+ 1);
2133 bcopy (*argptr
, copy
, p
- *argptr
);
2134 copy
[p
- *argptr
] = 0;
2135 while (*p
== ' ' || *p
== '\t') p
++;
2138 /* Look up that token as a variable.
2139 If file specified, use that file's per-file block to start with. */
2141 sym
= lookup_symbol (copy
,
2142 (s
? BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)
2143 : get_selected_block ()),
2144 VAR_NAMESPACE
, 0, &sym_symtab
);
2148 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2150 /* Arg is the name of a function */
2151 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) + FUNCTION_START_OFFSET
;
2154 val
= find_pc_line (pc
, 0);
2155 #ifdef PROLOGUE_FIRSTLINE_OVERLAP
2156 /* Convex: no need to suppress code on first line, if any */
2159 val
.pc
= (val
.end
&& val
.pc
!= pc
) ? val
.end
: pc
;
2161 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
2162 values
.sals
[0] = val
;
2165 /* I think this is always the same as the line that
2166 we calculate above, but the general principle is
2167 "trust the symbols more than stuff like
2169 if (SYMBOL_LINE (sym
) != 0)
2170 values
.sals
[0].line
= SYMBOL_LINE (sym
);
2174 else if (SYMBOL_LINE (sym
) != 0)
2176 /* We know its line number. */
2177 values
.sals
= (struct symtab_and_line
*)
2178 xmalloc (sizeof (struct symtab_and_line
));
2180 bzero (&values
.sals
[0], sizeof (values
.sals
[0]));
2181 values
.sals
[0].symtab
= sym_symtab
;
2182 values
.sals
[0].line
= SYMBOL_LINE (sym
);
2186 /* This can happen if it is compiled with a compiler which doesn't
2187 put out line numbers for variables. */
2188 error ("Line number not known for symbol \"%s\"", copy
);
2191 if ((i
= lookup_misc_func (copy
)) >= 0)
2195 val
.pc
= misc_function_vector
[i
].address
+ FUNCTION_START_OFFSET
;
2197 SKIP_PROLOGUE (val
.pc
);
2198 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
2199 values
.sals
[0] = val
;
2204 if (symtab_list
== 0 && partial_symtab_list
== 0 && misc_function_count
== 0)
2205 error (no_symtab_msg
);
2207 error ("Function %s not defined.", copy
);
2208 return values
; /* for lint */
2211 struct symtabs_and_lines
2212 decode_line_spec (string
, funfirstline
)
2216 struct symtabs_and_lines sals
;
2218 error ("Empty line specification.");
2219 sals
= decode_line_1 (&string
, funfirstline
,
2220 current_source_symtab
, current_source_line
);
2222 error ("Junk at end of line specification: %s", string
);
2226 /* Given a list of NELTS symbols in sym_arr (with corresponding
2227 mangled names in physnames), return a list of lines to operate on
2228 (ask user if necessary). */
2229 struct symtabs_and_lines
2230 decode_line_2 (sym_arr
, nelts
, funfirstline
)
2231 struct symbol
*sym_arr
[];
2235 struct symtabs_and_lines values
, return_values
;
2236 register CORE_ADDR pc
;
2237 char *args
, *arg1
, *command_line_input ();
2241 values
.sals
= (struct symtab_and_line
*) alloca (nelts
* sizeof(struct symtab_and_line
));
2242 return_values
.sals
= (struct symtab_and_line
*) xmalloc (nelts
* sizeof(struct symtab_and_line
));
2245 printf("[0] cancel\n[1] all\n");
2248 if (sym_arr
[i
] && SYMBOL_CLASS (sym_arr
[i
]) == LOC_BLOCK
)
2250 /* Arg is the name of a function */
2251 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym_arr
[i
]))
2252 + FUNCTION_START_OFFSET
;
2255 values
.sals
[i
] = find_pc_line (pc
, 0);
2256 values
.sals
[i
].pc
= (values
.sals
[i
].end
&& values
.sals
[i
].pc
!= pc
) ?
2257 values
.sals
[i
].end
: pc
;
2258 printf("[%d] file:%s; line number:%d\n",
2259 (i
+2), values
.sals
[i
].symtab
->filename
, values
.sals
[i
].line
);
2261 else printf ("?HERE\n");
2265 if ((prompt
= getenv ("PS2")) == NULL
)
2269 printf("%s ",prompt
);
2272 args
= command_line_input (0, 0);
2275 error_no_arg ("one or more choice numbers");
2283 while (*arg1
>= '0' && *arg1
<= '9') arg1
++;
2284 if (*arg1
&& *arg1
!= ' ' && *arg1
!= '\t')
2285 error ("Arguments must be choice numbers.");
2290 error ("cancelled");
2293 bcopy (values
.sals
, return_values
.sals
, (nelts
* sizeof(struct symtab_and_line
)));
2294 return_values
.nelts
= nelts
;
2295 return return_values
;
2298 if (num
> nelts
+ 2)
2300 printf ("No choice number %d.\n", num
);
2305 if (values
.sals
[num
].pc
)
2307 return_values
.sals
[i
++] = values
.sals
[num
];
2308 values
.sals
[num
].pc
= 0;
2312 printf ("duplicate request for %d ignored.\n", num
);
2317 while (*args
== ' ' || *args
== '\t') args
++;
2319 return_values
.nelts
= i
;
2320 return return_values
;
2323 /* Return the index of misc function named NAME. */
2326 lookup_misc_func (name
)
2327 register char *name
;
2331 for (i
= 0; i
< misc_function_count
; i
++)
2332 if (!strcmp (misc_function_vector
[i
].name
, name
))
2334 return -1; /* not found */
2337 /* Slave routine for sources_info. Force line breaks at ,'s.
2338 NAME is the name to print and *FIRST is nonzero if this is the first
2339 name printed. Set *FIRST to zero. */
2341 output_source_filename (name
, first
)
2346 /* Table of files printed so far. Since a single source file can
2347 result in several partial symbol tables, we need to avoid printing
2348 it more than once. Note: if some of the psymtabs are read in and
2349 some are not, it gets printed both under "Source files for which
2350 symbols have been read" and "Source files for which symbols will
2351 be read in on demand". I consider this a reasonable way to deal
2352 with the situation. I'm not sure whether this can also happen for
2353 symtabs; it doesn't hurt to check. */
2354 static char **tab
= NULL
;
2355 /* Allocated size of tab in elements.
2356 Start with one 256-byte block (when using GNU malloc.c).
2357 24 is the malloc overhead when range checking is in effect. */
2358 static int tab_alloc_size
= (256 - 24) / sizeof (char *);
2359 /* Current size of tab in elements. */
2360 static int tab_cur_size
;
2367 tab
= (char **) xmalloc (tab_alloc_size
* sizeof (*tab
));
2371 /* Is NAME in tab? */
2372 for (p
= tab
; p
< tab
+ tab_cur_size
; p
++)
2373 if (strcmp (*p
, name
) == 0)
2374 /* Yes; don't print it again. */
2376 /* No; add it to tab. */
2377 if (tab_cur_size
== tab_alloc_size
)
2379 tab_alloc_size
*= 2;
2380 tab
= (char **) xrealloc (tab
, tab_alloc_size
* sizeof (*tab
));
2382 tab
[tab_cur_size
++] = name
;
2391 printf_filtered (",");
2395 if (column
!= 0 && column
+ strlen (name
) >= 70)
2397 printf_filtered ("\n");
2400 else if (column
!= 0)
2402 printf_filtered (" ");
2405 fputs_filtered (name
, stdout
);
2406 column
+= strlen (name
);
2412 register struct symtab
*s
;
2413 register struct partial_symtab
*ps
;
2416 if (symtab_list
== 0 && partial_symtab_list
== 0)
2418 printf (no_symtab_msg
);
2422 printf_filtered ("Source files for which symbols have been read in:\n\n");
2425 for (s
= symtab_list
; s
; s
= s
->next
)
2426 output_source_filename (s
->filename
, &first
);
2427 printf_filtered ("\n\n");
2429 printf_filtered ("Source files for which symbols will be read in on demand:\n\n");
2432 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
2434 output_source_filename (ps
->filename
, &first
);
2435 printf_filtered ("\n");
2438 /* List all symbols (if REGEXP is 0) or all symbols matching REGEXP.
2439 If CLASS is zero, list all symbols except functions and type names.
2440 If CLASS is 1, list only functions.
2441 If CLASS is 2, list only type names.
2442 If CLASS is 3, list only method names.
2444 BPT is non-zero if we should set a breakpoint at the functions
2448 list_symbols (regexp
, class, bpt
)
2453 register struct symtab
*s
;
2454 register struct partial_symtab
*ps
;
2455 register struct blockvector
*bv
;
2456 struct blockvector
*prev_bv
= 0;
2457 register struct block
*b
;
2459 register struct symbol
*sym
;
2460 struct partial_symbol
*psym
;
2462 static char *classnames
[]
2463 = {"variable", "function", "type", "method"};
2464 int found_in_file
= 0;
2466 static enum misc_function_type types
[]
2467 = {mf_data
, mf_text
, mf_abs
, mf_unknown
};
2468 static enum misc_function_type types2
[]
2469 = {mf_bss
, mf_text
, mf_abs
, mf_unknown
};
2470 enum misc_function_type ourtype
= types
[class];
2471 enum misc_function_type ourtype2
= types2
[class];
2474 if (0 != (val
= re_comp (regexp
)))
2475 error ("Invalid regexp (%s): %s", val
, regexp
);
2477 /* Search through the partial_symtab_list *first* for all symbols
2478 matching the regexp. That way we don't have to reproduce all of
2479 the machinery below. */
2480 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
2482 struct partial_symbol
*bound
, *gbound
, *sbound
;
2485 if (ps
->readin
) continue;
2487 gbound
= global_psymbols
.list
+ ps
->globals_offset
+ ps
->n_global_syms
;
2488 sbound
= static_psymbols
.list
+ ps
->statics_offset
+ ps
->n_static_syms
;
2491 /* Go through all of the symbols stored in a partial
2492 symtab in one loop. */
2493 psym
= global_psymbols
.list
+ ps
->globals_offset
;
2498 if (bound
== gbound
&& ps
->n_static_syms
!= 0)
2500 psym
= static_psymbols
.list
+ ps
->statics_offset
;
2511 /* If it would match (logic taken from loop below)
2512 load the file and go on to the next one */
2513 if ((regexp
== 0 || re_exec (SYMBOL_NAME (psym
)))
2514 && ((class == 0 && SYMBOL_CLASS (psym
) != LOC_TYPEDEF
2515 && SYMBOL_CLASS (psym
) != LOC_BLOCK
)
2516 || (class == 1 && SYMBOL_CLASS (psym
) == LOC_BLOCK
)
2517 || (class == 2 && SYMBOL_CLASS (psym
) == LOC_TYPEDEF
)
2518 || (class == 3 && SYMBOL_CLASS (psym
) == LOC_BLOCK
)))
2520 (void) PSYMTAB_TO_SYMTAB(ps
);
2528 /* Here, we search through the misc function vector for functions that
2529 match, and call find_pc_symtab on them to force their symbols to
2530 be read. The symbol will then be found during the scan of symtabs
2531 below. If find_pc_symtab fails, set found_misc so that we will
2532 rescan to print any matching symbols without debug info. */
2535 for (i
= 0; i
< misc_function_count
; i
++) {
2536 if (misc_function_vector
[i
].type
!= ourtype
2537 && misc_function_vector
[i
].type
!= ourtype2
)
2539 if (regexp
== 0 || re_exec (misc_function_vector
[i
].name
)) {
2540 if (0 == find_pc_symtab (misc_function_vector
[i
].address
))
2546 /* Printout here so as to get after the "Reading in symbols"
2547 messages which will be generated above. */
2549 printf_filtered (regexp
2550 ? "All %ss matching regular expression \"%s\":\n"
2551 : "All defined %ss:\n",
2555 for (s
= symtab_list
; s
; s
= s
->next
)
2558 bv
= BLOCKVECTOR (s
);
2559 /* Often many files share a blockvector.
2560 Scan each blockvector only once so that
2561 we don't get every symbol many times.
2562 It happens that the first symtab in the list
2563 for any given blockvector is the main file. */
2565 for (i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; i
++)
2567 b
= BLOCKVECTOR_BLOCK (bv
, i
);
2568 /* Skip the sort if this block is always sorted. */
2569 if (!BLOCK_SHOULD_SORT (b
))
2570 sort_block_syms (b
);
2571 for (j
= 0; j
< BLOCK_NSYMS (b
); j
++)
2574 sym
= BLOCK_SYM (b
, j
);
2575 if ((regexp
== 0 || re_exec (SYMBOL_NAME (sym
)))
2576 && ((class == 0 && SYMBOL_CLASS (sym
) != LOC_TYPEDEF
2577 && SYMBOL_CLASS (sym
) != LOC_BLOCK
)
2578 || (class == 1 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2579 || (class == 2 && SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
2580 || (class == 3 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)))
2584 /* Set a breakpoint here, if it's a function */
2586 break_command (SYMBOL_NAME(sym
), 0);
2588 else if (!found_in_file
)
2590 fputs_filtered ("\nFile ", stdout
);
2591 fputs_filtered (s
->filename
, stdout
);
2592 fputs_filtered (":\n", stdout
);
2596 if (class != 2 && i
== STATIC_BLOCK
)
2597 printf_filtered ("static ");
2599 /* Typedef that is not a C++ class */
2601 && SYMBOL_NAMESPACE (sym
) != STRUCT_NAMESPACE
)
2602 typedef_print (SYMBOL_TYPE(sym
), sym
, stdout
);
2603 /* variable, func, or typedef-that-is-c++-class */
2604 else if (class < 2 ||
2606 SYMBOL_NAMESPACE(sym
) == STRUCT_NAMESPACE
))
2608 type_print (SYMBOL_TYPE (sym
),
2609 (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
2610 ? "" : SYMBOL_NAME (sym
)),
2613 printf_filtered (";\n");
2619 type_print_base (TYPE_FN_FIELD_TYPE(t
, i
), stdout
, 0, 0);
2620 type_print_varspec_prefix (TYPE_FN_FIELD_TYPE(t
, i
), stdout
, 0);
2621 sprintf (buf
, " %s::", type_name_no_tag (t
));
2622 type_print_method_args (TYPE_FN_FIELD_ARGS (t
, i
), buf
, name
, stdout
);
2632 /* If there are no eyes, avoid all contact. I mean, if there are
2633 no debug symbols, then print directly from the misc_function_vector. */
2635 if (found_misc
|| class != 1) {
2637 for (i
= 0; i
< misc_function_count
; i
++) {
2638 if (misc_function_vector
[i
].type
!= ourtype
2639 && misc_function_vector
[i
].type
!= ourtype2
)
2641 if (regexp
== 0 || re_exec (misc_function_vector
[i
].name
)) {
2642 /* Functions: Look up by address. */
2644 if (0 != find_pc_symtab (misc_function_vector
[i
].address
))
2646 /* Variables/Absolutes: Look up by name */
2647 if (0 != lookup_symbol (misc_function_vector
[i
].name
,
2648 (struct block
*)0, VAR_NAMESPACE
, 0, (struct symtab
**)0))
2650 if (!found_in_file
) {
2651 printf_filtered ("\nNon-debugging symbols:\n");
2654 printf_filtered (" %08x %s\n",
2655 misc_function_vector
[i
].address
,
2656 misc_function_vector
[i
].name
);
2663 variables_info (regexp
)
2666 list_symbols (regexp
, 0, 0);
2670 functions_info (regexp
)
2673 list_symbols (regexp
, 1, 0);
2680 list_symbols (regexp
, 2, 0);
2684 /* Tiemann says: "info methods was never implemented." */
2686 methods_info (regexp
)
2689 list_symbols (regexp
, 3, 0);
2693 /* Breakpoint all functions matching regular expression. */
2695 rbreak_command (regexp
)
2698 list_symbols (regexp
, 1, 1);
2701 /* Helper function to initialize the standard scalar types. */
2704 init_type (code
, length
, uns
, name
)
2705 enum type_code code
;
2709 register struct type
*type
;
2711 type
= (struct type
*) xmalloc (sizeof (struct type
));
2712 bzero (type
, sizeof *type
);
2713 TYPE_MAIN_VARIANT (type
) = type
;
2714 TYPE_CODE (type
) = code
;
2715 TYPE_LENGTH (type
) = length
;
2716 TYPE_FLAGS (type
) = uns
? TYPE_FLAG_UNSIGNED
: 0;
2717 TYPE_FLAGS (type
) |= TYPE_FLAG_PERM
;
2718 TYPE_NFIELDS (type
) = 0;
2719 TYPE_NAME (type
) = name
;
2722 TYPE_NFN_FIELDS (type
) = 0;
2723 TYPE_N_BASECLASSES (type
) = 0;
2727 /* Return Nonzero if block a is lexically nested within block b,
2728 or if a and b have the same pc range.
2729 Return zero otherwise. */
2732 struct block
*a
, *b
;
2736 return BLOCK_START (a
) >= BLOCK_START (b
)
2737 && BLOCK_END (a
) <= BLOCK_END (b
);
2741 /* Helper routine for make_symbol_completion_list. */
2743 int return_val_size
, return_val_index
;
2747 completion_list_add_symbol (symname
)
2750 if (return_val_index
+ 3 > return_val_size
)
2752 (char **)xrealloc (return_val
,
2753 (return_val_size
*= 2) * sizeof (char *));
2755 return_val
[return_val_index
] =
2756 (char *)xmalloc (1 + strlen (symname
));
2758 strcpy (return_val
[return_val_index
], symname
);
2760 return_val
[++return_val_index
] = (char *)NULL
;
2763 /* Return a NULL terminated array of all symbols (regardless of class) which
2764 begin by matching TEXT. If the answer is no symbols, then the return value
2765 is an array which contains only a NULL pointer.
2767 Problem: All of the symbols have to be copied because readline
2768 frees them. I'm not going to worry about this; hopefully there
2769 won't be that many. */
2772 make_symbol_completion_list (text
)
2775 register struct symtab
*s
;
2776 register struct partial_symtab
*ps
;
2777 register struct block
*b
, *surrounding_static_block
= 0;
2778 extern struct block
*get_selected_block ();
2780 struct partial_symbol
*psym
;
2782 int text_len
= strlen (text
);
2783 return_val_size
= 100;
2784 return_val_index
= 0;
2786 (char **)xmalloc ((1 + return_val_size
) *sizeof (char *));
2787 return_val
[0] = (char *)NULL
;
2789 /* Look through the partial symtabs for all symbols which begin
2790 by matching TEXT. Add each one that you find to the list. */
2792 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
2794 /* If the psymtab's been read in we'll get it when we search
2795 through the blockvector. */
2796 if (ps
->readin
) continue;
2798 for (psym
= global_psymbols
.list
+ ps
->globals_offset
;
2799 psym
< (global_psymbols
.list
+ ps
->globals_offset
2800 + ps
->n_global_syms
);
2803 QUIT
; /* If interrupted, then quit. */
2804 if ((strncmp (SYMBOL_NAME (psym
), text
, text_len
) == 0))
2805 completion_list_add_symbol (SYMBOL_NAME (psym
));
2808 for (psym
= static_psymbols
.list
+ ps
->statics_offset
;
2809 psym
< (static_psymbols
.list
+ ps
->statics_offset
2810 + ps
->n_static_syms
);
2814 if ((strncmp (SYMBOL_NAME (psym
), text
, text_len
) == 0))
2815 completion_list_add_symbol (SYMBOL_NAME (psym
));
2819 /* At this point scan through the misc function vector and add each
2820 symbol you find to the list. Eventually we want to ignore
2821 anything that isn't a text symbol (everything else will be
2822 handled by the psymtab code above). */
2824 for (i
= 0; i
< misc_function_count
; i
++)
2825 if (!strncmp (text
, misc_function_vector
[i
].name
, text_len
))
2826 completion_list_add_symbol (misc_function_vector
[i
].name
);
2828 /* Search upwards from currently selected frame (so that we can
2829 complete on local vars. */
2830 for (b
= get_selected_block (); b
; b
= BLOCK_SUPERBLOCK (b
))
2832 if (!BLOCK_SUPERBLOCK (b
))
2833 surrounding_static_block
= b
; /* For elmin of dups */
2835 /* Also catch fields of types defined in this places which
2836 match our text string. Only complete on types visible
2837 from current context. */
2838 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2840 register struct symbol
*sym
= BLOCK_SYM (b
, i
);
2842 if (!strncmp (SYMBOL_NAME (sym
), text
, text_len
))
2843 completion_list_add_symbol (SYMBOL_NAME (sym
));
2845 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
2847 struct type
*t
= SYMBOL_TYPE (sym
);
2848 enum type_code c
= TYPE_CODE (t
);
2850 if (c
== TYPE_CODE_UNION
|| c
== TYPE_CODE_STRUCT
)
2851 for (j
= TYPE_N_BASECLASSES (t
); j
< TYPE_NFIELDS (t
); j
++)
2852 if (TYPE_FIELD_NAME (t
, j
) &&
2853 !strncmp (TYPE_FIELD_NAME (t
, j
), text
, text_len
))
2854 completion_list_add_symbol (TYPE_FIELD_NAME (t
, j
));
2859 /* Go through the symtabs and check the externs and statics for
2860 symbols which match. */
2862 for (s
= symtab_list
; s
; s
= s
->next
)
2864 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
2866 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2867 if (!strncmp (SYMBOL_NAME (BLOCK_SYM (b
, i
)), text
, text_len
))
2868 completion_list_add_symbol (SYMBOL_NAME (BLOCK_SYM (b
, i
)));
2871 for (s
= symtab_list
; s
; s
= s
->next
)
2873 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
2875 /* Don't do this block twice. */
2876 if (b
== surrounding_static_block
) continue;
2878 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2879 if (!strncmp (SYMBOL_NAME (BLOCK_SYM (b
, i
)), text
, text_len
))
2880 completion_list_add_symbol (SYMBOL_NAME (BLOCK_SYM (b
, i
)));
2883 return (return_val
);
2887 /* Add the type of the symbol sym to the type of the current
2888 function whose block we are in (assumed). The type of
2889 this current function is contained in *TYPE.
2891 This basically works as follows: When we find a function
2892 symbol (N_FUNC with a 'f' or 'F' in the symbol name), we record
2893 a pointer to its type in the global in_function_type. Every
2894 time we come across a parameter symbol ('p' in its name), then
2895 this procedure adds the name and type of that parameter
2896 to the function type pointed to by *TYPE. (Which should correspond
2897 to in_function_type if it was called correctly).
2899 Note that since we are modifying a type, the result of
2900 lookup_function_type() should be bcopy()ed before calling
2901 this. When not in strict typing mode, the expression
2902 evaluator can choose to ignore this.
2904 Assumption: All of a function's parameter symbols will
2905 appear before another function symbol is found. The parameters
2906 appear in the same order in the argument list as they do in the
2910 add_param_to_type (type
,sym
)
2914 int num
= ++(TYPE_NFIELDS(*type
));
2916 if(TYPE_NFIELDS(*type
)-1)
2917 TYPE_FIELDS(*type
) =
2918 (struct field
*)xrealloc((char *)(TYPE_FIELDS(*type
)),
2919 num
*sizeof(struct field
));
2921 TYPE_FIELDS(*type
) =
2922 (struct field
*)xmalloc(num
*sizeof(struct field
));
2924 TYPE_FIELD_BITPOS(*type
,num
-1) = num
-1;
2925 TYPE_FIELD_BITSIZE(*type
,num
-1) = 0;
2926 TYPE_FIELD_TYPE(*type
,num
-1) = SYMBOL_TYPE(sym
);
2927 TYPE_FIELD_NAME(*type
,num
-1) = SYMBOL_NAME(sym
);
2932 _initialize_symtab ()
2934 add_info ("variables", variables_info
,
2935 "All global and static variable names, or those matching REGEXP.");
2936 add_info ("functions", functions_info
,
2937 "All function names, or those matching REGEXP.");
2939 /* FIXME: This command has at least the following problems:
2940 1. It prints builtin types (in a very strange and confusing fashion).
2941 2. It doesn't print right, e.g. with
2942 typedef struct foo *FOO
2943 type_print prints "FOO" when we want to make it (in this situation)
2944 print "struct foo *".
2945 I also think "ptype" or "whatis" is more likely to be useful (but if
2946 there is much disagreement "info types" can be fixed). */
2947 add_info ("types", types_info
,
2948 "All types names, or those matching REGEXP.");
2951 add_info ("methods", methods_info
,
2952 "All method names, or those matching REGEXP::REGEXP.\n\
2953 If the class qualifier is ommited, it is assumed to be the current scope.\n\
2954 If the first REGEXP is ommited, then all methods matching the second REGEXP\n\
2957 add_info ("sources", sources_info
,
2958 "Source files in the program.");
2960 add_com ("rbreak", no_class
, rbreak_command
,
2961 "Set a breakpoint for all functions matching REGEXP.");
2963 /* Initialize the one built-in type that isn't language dependent... */
2964 builtin_type_error
= init_type (TYPE_CODE_ERROR
, 0, 0, "<unknown type>");