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 TYPE_LENGTH (ptype
) = sizeof (char *);
441 TYPE_CODE (ptype
) = TYPE_CODE_PTR
;
446 lookup_reference_type (type
)
449 register struct type
*rtype
= TYPE_REFERENCE_TYPE (type
);
450 if (rtype
) return TYPE_MAIN_VARIANT (rtype
);
452 /* This is the first time anyone wanted a pointer to a TYPE. */
453 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
454 rtype
= (struct type
*) xmalloc (sizeof (struct type
));
456 rtype
= (struct type
*) obstack_alloc (symbol_obstack
,
457 sizeof (struct type
));
459 bzero (rtype
, sizeof (struct type
));
460 TYPE_MAIN_VARIANT (rtype
) = rtype
;
461 TYPE_TARGET_TYPE (rtype
) = type
;
462 TYPE_REFERENCE_TYPE (type
) = rtype
;
463 /* New type is permanent if type pointed to is permanent. */
464 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
465 TYPE_FLAGS (rtype
) |= TYPE_FLAG_PERM
;
466 /* We assume the machine has only one representation for pointers! */
467 TYPE_LENGTH (rtype
) = sizeof (char *);
468 TYPE_CODE (rtype
) = TYPE_CODE_REF
;
473 /* Implement direct support for MEMBER_TYPE in GNU C++.
474 May need to construct such a type if this is the first use.
475 The TYPE is the type of the member. The DOMAIN is the type
476 of the aggregate that the member belongs to. */
479 lookup_member_type (type
, domain
)
480 struct type
*type
, *domain
;
482 register struct type
*mtype
= TYPE_MAIN_VARIANT (type
);
483 struct type
*main_type
;
488 if (TYPE_DOMAIN_TYPE (mtype
) == domain
)
490 mtype
= TYPE_NEXT_VARIANT (mtype
);
493 /* This is the first time anyone wanted this member type. */
494 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
495 mtype
= (struct type
*) xmalloc (sizeof (struct type
));
497 mtype
= (struct type
*) obstack_alloc (symbol_obstack
,
498 sizeof (struct type
));
500 bzero (mtype
, sizeof (struct type
));
505 TYPE_NEXT_VARIANT (mtype
) = TYPE_NEXT_VARIANT (main_type
);
506 TYPE_NEXT_VARIANT (main_type
) = mtype
;
508 TYPE_MAIN_VARIANT (mtype
) = main_type
;
509 TYPE_TARGET_TYPE (mtype
) = type
;
510 TYPE_DOMAIN_TYPE (mtype
) = domain
;
511 /* New type is permanent if type pointed to is permanent. */
512 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
513 TYPE_FLAGS (mtype
) |= TYPE_FLAG_PERM
;
515 /* In practice, this is never used. */
516 TYPE_LENGTH (mtype
) = 1;
517 TYPE_CODE (mtype
) = TYPE_CODE_MEMBER
;
520 /* Now splice in the new member pointer type. */
523 /* This type was not "smashed". */
524 TYPE_CHAIN (mtype
) = TYPE_CHAIN (main_type
);
525 TYPE_CHAIN (main_type
) = mtype
;
532 /* Allocate a stub method whose return type is
533 TYPE. We will fill in arguments later. This always
534 returns a fresh type. If we unify this type with
535 an existing type later, the storage allocated
536 here can be freed. */
538 allocate_stub_method (type
)
541 struct type
*mtype
= (struct type
*)xmalloc (sizeof (struct type
));
542 bzero (mtype
, sizeof (struct type
));
543 TYPE_MAIN_VARIANT (mtype
) = mtype
;
544 TYPE_TARGET_TYPE (mtype
) = type
;
545 TYPE_FLAGS (mtype
) = TYPE_FLAG_STUB
;
546 TYPE_CODE (mtype
) = TYPE_CODE_METHOD
;
547 TYPE_LENGTH (mtype
) = 1;
551 /* Lookup a method type returning type TYPE, belonging
552 to class DOMAIN, and taking a list of arguments ARGS.
553 If one is not found, allocate a new one. */
556 lookup_method_type (type
, domain
, args
)
557 struct type
*type
, *domain
, **args
;
559 register struct type
*mtype
= TYPE_MAIN_VARIANT (type
);
560 struct type
*main_type
;
565 if (TYPE_DOMAIN_TYPE (mtype
) == domain
)
567 struct type
**t1
= args
;
568 struct type
**t2
= TYPE_ARG_TYPES (mtype
);
572 for (i
= 0; t1
[i
] != 0 && t1
[i
]->code
!= TYPE_CODE_VOID
; i
++)
579 mtype
= TYPE_NEXT_VARIANT (mtype
);
582 /* This is the first time anyone wanted this member type. */
583 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
584 mtype
= (struct type
*) xmalloc (sizeof (struct type
));
586 mtype
= (struct type
*) obstack_alloc (symbol_obstack
,
587 sizeof (struct type
));
589 bzero (mtype
, sizeof (struct type
));
594 TYPE_NEXT_VARIANT (mtype
) = TYPE_NEXT_VARIANT (main_type
);
595 TYPE_NEXT_VARIANT (main_type
) = mtype
;
597 TYPE_MAIN_VARIANT (mtype
) = main_type
;
598 TYPE_TARGET_TYPE (mtype
) = type
;
599 TYPE_DOMAIN_TYPE (mtype
) = domain
;
600 TYPE_ARG_TYPES (mtype
) = args
;
601 /* New type is permanent if type pointed to is permanent. */
602 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
603 TYPE_FLAGS (mtype
) |= TYPE_FLAG_PERM
;
605 /* In practice, this is never used. */
606 TYPE_LENGTH (mtype
) = 1;
607 TYPE_CODE (mtype
) = TYPE_CODE_METHOD
;
610 /* Now splice in the new member pointer type. */
613 /* This type was not "smashed". */
614 TYPE_CHAIN (mtype
) = TYPE_CHAIN (main_type
);
615 TYPE_CHAIN (main_type
) = mtype
;
623 /* Given a type TYPE, return a type which has offset OFFSET,
624 via_virtual VIA_VIRTUAL, and via_public VIA_PUBLIC.
625 May need to construct such a type if none exists. */
627 lookup_basetype_type (type
, offset
, via_virtual
, via_public
)
630 int via_virtual
, via_public
;
632 register struct type
*btype
= TYPE_MAIN_VARIANT (type
);
633 struct type
*main_type
;
637 printf ("Internal error: type offset non-zero in lookup_basetype_type");
644 if (/* TYPE_OFFSET (btype) == offset
645 && */ TYPE_VIA_PUBLIC (btype
) == via_public
646 && TYPE_VIA_VIRTUAL (btype
) == via_virtual
)
648 btype
= TYPE_NEXT_VARIANT (btype
);
651 /* This is the first time anyone wanted this member type. */
652 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
653 btype
= (struct type
*) xmalloc (sizeof (struct type
));
655 btype
= (struct type
*) obstack_alloc (symbol_obstack
,
656 sizeof (struct type
));
661 bzero (btype
, sizeof (struct type
));
662 TYPE_MAIN_VARIANT (btype
) = main_type
;
666 bcopy (main_type
, btype
, sizeof (struct type
));
667 TYPE_NEXT_VARIANT (main_type
) = btype
;
669 /* TYPE_OFFSET (btype) = offset; */
671 TYPE_FLAGS (btype
) |= TYPE_FLAG_VIA_PUBLIC
;
673 TYPE_FLAGS (btype
) |= TYPE_FLAG_VIA_VIRTUAL
;
674 /* New type is permanent if type pointed to is permanent. */
675 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
676 TYPE_FLAGS (btype
) |= TYPE_FLAG_PERM
;
678 /* In practice, this is never used. */
679 TYPE_LENGTH (btype
) = 1;
680 TYPE_CODE (btype
) = TYPE_CODE_STRUCT
;
686 /* Given a type TYPE, return a type of functions that return that type.
687 May need to construct such a type if this is the first use. */
690 lookup_function_type (type
)
693 register struct type
*ptype
= TYPE_FUNCTION_TYPE (type
);
694 if (ptype
) return ptype
;
696 /* This is the first time anyone wanted a function returning a TYPE. */
697 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
698 ptype
= (struct type
*) xmalloc (sizeof (struct type
));
700 ptype
= (struct type
*) obstack_alloc (symbol_obstack
,
701 sizeof (struct type
));
703 bzero (ptype
, sizeof (struct type
));
704 TYPE_TARGET_TYPE (ptype
) = type
;
705 TYPE_FUNCTION_TYPE (type
) = ptype
;
706 /* New type is permanent if type returned is permanent. */
707 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
708 TYPE_FLAGS (ptype
) |= TYPE_FLAG_PERM
;
709 TYPE_LENGTH (ptype
) = 1;
710 TYPE_CODE (ptype
) = TYPE_CODE_FUNC
;
711 TYPE_NFIELDS (ptype
) = 0;
715 /* Create an array type. Elements will be of type TYPE, and there will
718 Eventually this should be extended to take two more arguments which
719 specify the bounds of the array and the type of the index.
720 It should also be changed to be a "lookup" function, with the
721 appropriate data structures added to the type field.
722 Then read array type should call here. */
725 create_array_type (element_type
, number
)
726 struct type
*element_type
;
729 struct type
*result_type
= (struct type
*)
730 obstack_alloc (symbol_obstack
, sizeof (struct type
));
731 struct type
*range_type
;
733 bzero (result_type
, sizeof (struct type
));
735 TYPE_CODE (result_type
) = TYPE_CODE_ARRAY
;
736 TYPE_TARGET_TYPE (result_type
) = element_type
;
737 TYPE_LENGTH (result_type
) = number
* TYPE_LENGTH (element_type
);
738 TYPE_NFIELDS (result_type
) = 1;
739 TYPE_FIELDS (result_type
) =
740 (struct field
*) obstack_alloc (symbol_obstack
, sizeof (struct field
));
743 /* Create range type. */
744 range_type
= (struct type
*) obstack_alloc (symbol_obstack
,
745 sizeof (struct type
));
746 TYPE_CODE (range_type
) = TYPE_CODE_RANGE
;
747 TYPE_TARGET_TYPE (range_type
) = builtin_type_int
; /* FIXME */
749 /* This should never be needed. */
750 TYPE_LENGTH (range_type
) = sizeof (int);
752 TYPE_NFIELDS (range_type
) = 2;
753 TYPE_FIELDS (range_type
) =
754 (struct field
*) obstack_alloc (symbol_obstack
,
755 2 * sizeof (struct field
));
756 TYPE_FIELD_BITPOS (range_type
, 0) = 0; /* FIXME */
757 TYPE_FIELD_BITPOS (range_type
, 1) = number
-1; /* FIXME */
758 TYPE_FIELD_TYPE (range_type
, 0) = builtin_type_int
; /* FIXME */
759 TYPE_FIELD_TYPE (range_type
, 1) = builtin_type_int
; /* FIXME */
761 TYPE_FIELD_TYPE(result_type
,0)=range_type
;
762 TYPE_VPTR_FIELDNO (result_type
) = -1;
768 /* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE. */
771 smash_to_member_type (type
, domain
, to_type
)
772 struct type
*type
, *domain
, *to_type
;
774 bzero (type
, sizeof (struct type
));
775 TYPE_TARGET_TYPE (type
) = to_type
;
776 TYPE_DOMAIN_TYPE (type
) = domain
;
778 /* In practice, this is never needed. */
779 TYPE_LENGTH (type
) = 1;
780 TYPE_CODE (type
) = TYPE_CODE_MEMBER
;
782 TYPE_MAIN_VARIANT (type
) = lookup_member_type (domain
, to_type
);
785 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE. */
788 smash_to_method_type (type
, domain
, to_type
, args
)
789 struct type
*type
, *domain
, *to_type
, **args
;
791 bzero (type
, sizeof (struct type
));
792 TYPE_TARGET_TYPE (type
) = to_type
;
793 TYPE_DOMAIN_TYPE (type
) = domain
;
794 TYPE_ARG_TYPES (type
) = args
;
796 /* In practice, this is never needed. */
797 TYPE_LENGTH (type
) = 1;
798 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
800 TYPE_MAIN_VARIANT (type
) = lookup_method_type (domain
, to_type
, args
);
803 /* Find which partial symtab on the partial_symtab_list contains
804 PC. Return 0 if none. */
806 struct partial_symtab
*
808 register CORE_ADDR pc
;
810 register struct partial_symtab
*ps
;
812 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
813 if (pc
>= ps
->textlow
&& pc
< ps
->texthigh
)
819 /* Find which partial symbol within a psymtab contains PC. Return 0
820 if none. Check all psymtabs if PSYMTAB is 0. */
821 struct partial_symbol
*
822 find_pc_psymbol (psymtab
, pc
)
823 struct partial_symtab
*psymtab
;
826 struct partial_symbol
*best
, *p
;
830 psymtab
= find_pc_psymtab (pc
);
834 best_pc
= psymtab
->textlow
- 1;
836 for (p
= static_psymbols
.list
+ psymtab
->statics_offset
;
837 (p
- (static_psymbols
.list
+ psymtab
->statics_offset
)
838 < psymtab
->n_static_syms
);
840 if (SYMBOL_NAMESPACE (p
) == VAR_NAMESPACE
841 && SYMBOL_CLASS (p
) == LOC_BLOCK
842 && pc
>= SYMBOL_VALUE_ADDRESS (p
)
843 && SYMBOL_VALUE_ADDRESS (p
) > best_pc
)
845 best_pc
= SYMBOL_VALUE_ADDRESS (p
);
848 if (best_pc
== psymtab
->textlow
- 1)
854 /* Find the definition for a specified symbol name NAME
855 in namespace NAMESPACE, visible from lexical block BLOCK.
856 Returns the struct symbol pointer, or zero if no symbol is found.
857 If SYMTAB is non-NULL, store the symbol table in which the
858 symbol was found there, or NULL if not found.
859 C++: if IS_A_FIELD_OF_THIS is nonzero on entry, check to see if
860 NAME is a field of the current implied argument `this'. If so set
861 *IS_A_FIELD_OF_THIS to 1, otherwise set it to zero.
862 BLOCK_FOUND is set to the block in which NAME is found (in the case of
863 a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */
866 lookup_symbol (name
, block
, namespace, is_a_field_of_this
, symtab
)
868 register struct block
*block
;
869 enum namespace namespace;
870 int *is_a_field_of_this
;
871 struct symtab
**symtab
;
873 register struct symbol
*sym
;
874 register struct symtab
*s
;
875 register struct partial_symtab
*ps
;
876 struct blockvector
*bv
;
878 /* Search specified block and its superiors. */
882 sym
= lookup_block_symbol (block
, name
, namespace);
888 /* Search the list of symtabs for one which contains the
889 address of the start of this block. */
891 for (s
= symtab_list
; s
; s
= s
->next
)
893 bv
= BLOCKVECTOR (s
);
894 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
895 if (BLOCK_START (b
) <= BLOCK_START (block
)
896 && BLOCK_END (b
) > BLOCK_START (block
))
904 block
= BLOCK_SUPERBLOCK (block
);
907 /* But that doesn't do any demangling for the STATIC_BLOCK.
908 I'm not sure whether demangling is needed in the case of
909 nested function in inner blocks; if so this needs to be changed.
911 Don't need to mess with the psymtabs; if we have a block,
912 that file is read in. If we don't, then we deal later with
913 all the psymtab stuff that needs checking. */
914 if (namespace == VAR_NAMESPACE
&& block
!= NULL
)
917 /* Find the right symtab. */
918 for (s
= symtab_list
; s
; s
= s
->next
)
920 bv
= BLOCKVECTOR (s
);
921 b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
922 if (BLOCK_START (b
) <= BLOCK_START (block
)
923 && BLOCK_END (b
) > BLOCK_START (block
))
925 sym
= lookup_demangled_block_symbol (b
, name
);
938 /* C++: If requested to do so by the caller,
939 check to see if NAME is a field of `this'. */
940 if (is_a_field_of_this
)
942 struct value
*v
= value_of_this (0);
944 *is_a_field_of_this
= 0;
945 if (v
&& check_field (v
, name
))
947 *is_a_field_of_this
= 1;
954 /* Now search all global blocks. Do the symtab's first, then
955 check the psymtab's */
957 for (s
= symtab_list
; s
; s
= s
->next
)
959 bv
= BLOCKVECTOR (s
);
960 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
961 sym
= lookup_block_symbol (block
, name
, namespace);
971 /* Check for the possibility of the symbol being a global function
972 that is stored on the misc function vector. Eventually, all
973 global symbols might be resolved in this way. */
975 if (namespace == VAR_NAMESPACE
)
977 int ind
= lookup_misc_func (name
);
979 /* Look for a mangled C++ name for NAME. */
982 int name_len
= strlen (name
);
984 for (ind
= misc_function_count
; --ind
>= 0; )
985 /* Assume orginal name is prefix of mangled name. */
986 if (!strncmp (misc_function_vector
[ind
].name
, name
, name_len
))
989 cplus_demangle(misc_function_vector
[ind
].name
, -1);
990 if (demangled
!= NULL
)
992 int cond
= strcmp (demangled
, name
);
998 /* Loop terminates on no match with ind == -1. */
1003 s
= find_pc_symtab (misc_function_vector
[ind
].address
);
1004 /* If S is zero, there are no debug symbols for this file.
1005 Skip this stuff and check for matching static symbols below. */
1008 bv
= BLOCKVECTOR (s
);
1009 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1010 sym
= lookup_block_symbol (block
, misc_function_vector
[ind
].name
,
1012 /* sym == 0 if symbol was found in the misc_function_vector
1013 but not in the symtab.
1014 Return 0 to use the misc_function definition of "foo_".
1016 This happens for Fortran "foo_" symbols,
1017 which are "foo" in the symtab.
1019 This can also happen if "asm" is used to make a
1020 regular symbol but not a debugging symbol, e.g.
1021 asm(".globl _main");
1032 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
1033 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 1, namespace))
1035 s
= PSYMTAB_TO_SYMTAB(ps
);
1036 bv
= BLOCKVECTOR (s
);
1037 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1038 sym
= lookup_block_symbol (block
, name
, namespace);
1040 fatal ("Internal: global symbol found in psymtab but not in symtab");
1046 /* Now search all per-file blocks.
1047 Not strictly correct, but more useful than an error.
1048 Do the symtabs first, then check the psymtabs */
1050 for (s
= symtab_list
; s
; s
= s
->next
)
1052 bv
= BLOCKVECTOR (s
);
1053 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1054 sym
= lookup_block_symbol (block
, name
, namespace);
1057 block_found
= block
;
1064 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
1065 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 0, namespace))
1067 s
= PSYMTAB_TO_SYMTAB(ps
);
1068 bv
= BLOCKVECTOR (s
);
1069 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1070 sym
= lookup_block_symbol (block
, name
, namespace);
1072 fatal ("Internal: static symbol found in psymtab but not in symtab");
1078 /* Now search all per-file blocks for static mangled symbols.
1079 Do the symtabs first, then check the psymtabs. */
1081 if (namespace == VAR_NAMESPACE
)
1083 for (s
= symtab_list
; s
; s
= s
->next
)
1085 bv
= BLOCKVECTOR (s
);
1086 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1087 sym
= lookup_demangled_block_symbol (block
, name
);
1090 block_found
= block
;
1097 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
1098 if (!ps
->readin
&& lookup_demangled_partial_symbol (ps
, name
))
1100 s
= PSYMTAB_TO_SYMTAB(ps
);
1101 bv
= BLOCKVECTOR (s
);
1102 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1103 sym
= lookup_demangled_block_symbol (block
, name
);
1105 fatal ("Internal: static symbol found in psymtab but not in symtab");
1117 /* Look for a static demangled symbol in block BLOCK. */
1119 static struct symbol
*
1120 lookup_demangled_block_symbol (block
, name
)
1121 register struct block
*block
;
1124 register int bot
, top
, inc
;
1125 register struct symbol
*sym
;
1128 top
= BLOCK_NSYMS (block
);
1133 sym
= BLOCK_SYM (block
, bot
);
1134 if (SYMBOL_NAME (sym
)[0] == inc
1135 && SYMBOL_NAMESPACE (sym
) == VAR_NAMESPACE
)
1137 char *demangled
= cplus_demangle(SYMBOL_NAME (sym
), -1);
1138 if (demangled
!= NULL
)
1140 int cond
= strcmp (demangled
, name
);
1152 /* Look, in partial_symtab PST, for static mangled symbol NAME. */
1154 static struct partial_symbol
*
1155 lookup_demangled_partial_symbol (pst
, name
)
1156 struct partial_symtab
*pst
;
1159 struct partial_symbol
*start
, *psym
;
1160 int length
= pst
->n_static_syms
;
1161 register int inc
= name
[0];
1164 return (struct partial_symbol
*) 0;
1166 start
= static_psymbols
.list
+ pst
->statics_offset
;
1167 for (psym
= start
; psym
< start
+ length
; psym
++)
1169 if (SYMBOL_NAME (psym
)[0] == inc
1170 && SYMBOL_NAMESPACE (psym
) == VAR_NAMESPACE
)
1172 char *demangled
= cplus_demangle(SYMBOL_NAME (psym
), -1);
1173 if (demangled
!= NULL
)
1175 int cond
= strcmp (demangled
, name
);
1183 return (struct partial_symbol
*) 0;
1186 /* Look, in partial_symtab PST, for symbol NAME. Check the global
1187 symbols if GLOBAL, the static symbols if not */
1189 static struct partial_symbol
*
1190 lookup_partial_symbol (pst
, name
, global
, namespace)
1191 struct partial_symtab
*pst
;
1194 enum namespace namespace;
1196 struct partial_symbol
*start
, *psym
;
1197 int length
= (global
? pst
->n_global_syms
: pst
->n_static_syms
);
1200 return (struct partial_symbol
*) 0;
1203 global_psymbols
.list
+ pst
->globals_offset
:
1204 static_psymbols
.list
+ pst
->statics_offset
);
1206 if (global
) /* This means we can use a binary */
1209 struct partial_symbol
*top
, *bottom
, *center
;
1211 /* Binary search. This search is guaranteed to end with center
1212 pointing at the earliest partial symbol with the correct
1213 name. At that point *all* partial symbols with that name
1214 will be checked against the correct namespace. */
1216 top
= start
+ length
- 1;
1217 while (top
> bottom
)
1219 center
= bottom
+ (top
- bottom
) / 2;
1221 assert (center
< top
);
1223 if (strcmp (SYMBOL_NAME (center
), name
) >= 0)
1226 bottom
= center
+ 1;
1228 assert (top
== bottom
);
1230 while (!strcmp (SYMBOL_NAME (top
), name
))
1232 if (SYMBOL_NAMESPACE (top
) == namespace)
1239 /* Can't use a binary search */
1240 for (psym
= start
; psym
< start
+ length
; psym
++)
1241 if (namespace == SYMBOL_NAMESPACE (psym
)
1242 && !strcmp (name
, SYMBOL_NAME (psym
)))
1246 return (struct partial_symbol
*) 0;
1249 /* Look for a symbol in block BLOCK. */
1252 lookup_block_symbol (block
, name
, namespace)
1253 register struct block
*block
;
1255 enum namespace namespace;
1257 register int bot
, top
, inc
;
1258 register struct symbol
*sym
, *parameter_sym
;
1260 top
= BLOCK_NSYMS (block
);
1263 /* If the blocks's symbols were sorted, start with a binary search. */
1265 if (BLOCK_SHOULD_SORT (block
))
1267 /* First, advance BOT to not far before
1268 the first symbol whose name is NAME. */
1272 inc
= (top
- bot
+ 1);
1273 /* No need to keep binary searching for the last few bits worth. */
1276 inc
= (inc
>> 1) + bot
;
1277 sym
= BLOCK_SYM (block
, inc
);
1278 if (SYMBOL_NAME (sym
)[0] < name
[0])
1280 else if (SYMBOL_NAME (sym
)[0] > name
[0])
1282 else if (strcmp (SYMBOL_NAME (sym
), name
) < 0)
1288 /* Now scan forward until we run out of symbols,
1289 find one whose name is greater than NAME,
1290 or find one we want.
1291 If there is more than one symbol with the right name and namespace,
1292 we return the first one. dbxread.c is careful to make sure
1293 that if one is a register then it comes first. */
1295 top
= BLOCK_NSYMS (block
);
1298 sym
= BLOCK_SYM (block
, bot
);
1299 inc
= SYMBOL_NAME (sym
)[0] - name
[0];
1301 inc
= strcmp (SYMBOL_NAME (sym
), name
);
1302 if (inc
== 0 && SYMBOL_NAMESPACE (sym
) == namespace)
1311 /* Here if block isn't sorted.
1312 This loop is equivalent to the loop above,
1313 but hacked greatly for speed.
1315 Note that parameter symbols do not always show up last in the
1316 list; this loop makes sure to take anything else other than
1317 parameter symbols first; it only uses parameter symbols as a
1318 last resort. Note that this only takes up extra computation
1321 parameter_sym
= (struct symbol
*) 0;
1322 top
= BLOCK_NSYMS (block
);
1326 sym
= BLOCK_SYM (block
, bot
);
1327 if (SYMBOL_NAME (sym
)[0] == inc
1328 && !strcmp (SYMBOL_NAME (sym
), name
)
1329 && SYMBOL_NAMESPACE (sym
) == namespace)
1331 if (SYMBOL_CLASS (sym
) == LOC_ARG
1332 || SYMBOL_CLASS (sym
) == LOC_LOCAL_ARG
1333 || SYMBOL_CLASS (sym
) == LOC_REF_ARG
1334 || SYMBOL_CLASS (sym
) == LOC_REGPARM
)
1335 parameter_sym
= sym
;
1341 return parameter_sym
; /* Will be 0 if not found. */
1344 /* Return the symbol for the function which contains a specified
1345 lexical block, described by a struct block BL. */
1351 while (BLOCK_FUNCTION (bl
) == 0 && BLOCK_SUPERBLOCK (bl
) != 0)
1352 bl
= BLOCK_SUPERBLOCK (bl
);
1354 return BLOCK_FUNCTION (bl
);
1357 /* Subroutine of find_pc_line */
1361 register CORE_ADDR pc
;
1363 register struct block
*b
;
1364 struct blockvector
*bv
;
1365 register struct symtab
*s
;
1366 register struct partial_symtab
*ps
;
1368 /* Search all symtabs for one whose file contains our pc */
1370 for (s
= symtab_list
; s
; s
= s
->next
)
1372 bv
= BLOCKVECTOR (s
);
1373 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1374 if (BLOCK_START (b
) <= pc
1375 && BLOCK_END (b
) > pc
)
1381 ps
= find_pc_psymtab (pc
);
1382 if (ps
&& ps
->readin
)
1384 "(Internal error: pc in read in psymtab, but not in symtab.)\n");
1387 s
= PSYMTAB_TO_SYMTAB (ps
);
1393 /* Find the source file and line number for a given PC value.
1394 Return a structure containing a symtab pointer, a line number,
1395 and a pc range for the entire source line.
1396 The value's .pc field is NOT the specified pc.
1397 NOTCURRENT nonzero means, if specified pc is on a line boundary,
1398 use the line that ends there. Otherwise, in that case, the line
1399 that begins there is used. */
1401 struct symtab_and_line
1402 find_pc_line (pc
, notcurrent
)
1407 register struct linetable
*l
;
1410 register struct linetable_entry
*item
;
1411 struct symtab_and_line val
;
1412 struct blockvector
*bv
;
1414 /* Info on best line seen so far, and where it starts, and its file. */
1417 CORE_ADDR best_pc
= 0;
1418 CORE_ADDR best_end
= 0;
1419 struct symtab
*best_symtab
= 0;
1421 /* Store here the first line number
1422 of a file which contains the line at the smallest pc after PC.
1423 If we don't find a line whose range contains PC,
1424 we will use a line one less than this,
1425 with a range from the start of that file to the first line's pc. */
1427 CORE_ADDR alt_pc
= 0;
1428 struct symtab
*alt_symtab
= 0;
1430 /* Info on best line seen in this file. */
1435 /* Info on first line of this file. */
1440 /* If this pc is not from the current frame,
1441 it is the address of the end of a call instruction.
1442 Quite likely that is the start of the following statement.
1443 But what we want is the statement containing the instruction.
1444 Fudge the pc to make sure we get that. */
1446 if (notcurrent
) pc
-= 1;
1448 s
= find_pc_symtab (pc
);
1458 bv
= BLOCKVECTOR (s
);
1460 /* Look at all the symtabs that share this blockvector.
1461 They all have the same apriori range, that we found was right;
1462 but they have different line tables. */
1464 for (; s
&& BLOCKVECTOR (s
) == bv
; s
= s
->next
)
1466 /* Find the best line in this symtab. */
1471 for (i
= 0; i
< len
; i
++)
1473 item
= &(l
->item
[i
]);
1477 first_line
= item
->line
;
1478 first_pc
= item
->pc
;
1480 /* Return the last line that did not start after PC. */
1483 prev_line
= item
->line
;
1490 /* Is this file's best line closer than the best in the other files?
1491 If so, record this file, and its best line, as best so far. */
1492 if (prev_line
>= 0 && prev_pc
> best_pc
)
1495 best_line
= prev_line
;
1498 best_end
= item
->pc
;
1502 /* Is this file's first line closer than the first lines of other files?
1503 If so, record this file, and its first line, as best alternate. */
1504 if (first_line
>= 0 && first_pc
> pc
1505 && (alt_pc
== 0 || first_pc
< alt_pc
))
1508 alt_line
= first_line
;
1512 if (best_symtab
== 0)
1514 val
.symtab
= alt_symtab
;
1515 val
.line
= alt_line
- 1;
1516 val
.pc
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
1521 val
.symtab
= best_symtab
;
1522 val
.line
= best_line
;
1524 val
.end
= (best_end
? best_end
1526 : BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
))));
1531 /* Find the PC value for a given source file and line number.
1532 Returns zero for invalid line number.
1533 The source file is specified with a struct symtab. */
1536 find_line_pc (symtab
, line
)
1537 struct symtab
*symtab
;
1540 register struct linetable
*l
;
1546 l
= LINETABLE (symtab
);
1547 ind
= find_line_common(l
, line
, &dummy
);
1548 return (ind
>= 0) ? l
->item
[ind
].pc
: 0;
1551 /* Find the range of pc values in a line.
1552 Store the starting pc of the line into *STARTPTR
1553 and the ending pc (start of next line) into *ENDPTR.
1554 Returns 1 to indicate success.
1555 Returns 0 if could not find the specified line. */
1558 find_line_pc_range (symtab
, thisline
, startptr
, endptr
)
1559 struct symtab
*symtab
;
1561 CORE_ADDR
*startptr
, *endptr
;
1563 register struct linetable
*l
;
1565 int exact_match
; /* did we get an exact linenumber match */
1570 l
= LINETABLE (symtab
);
1571 ind
= find_line_common (l
, thisline
, &exact_match
);
1574 *startptr
= l
->item
[ind
].pc
;
1575 /* If we have not seen an entry for the specified line,
1576 assume that means the specified line has zero bytes. */
1577 if (!exact_match
|| ind
== l
->nitems
-1)
1578 *endptr
= *startptr
;
1580 /* Perhaps the following entry is for the following line.
1581 It's worth a try. */
1582 if (ind
+1 < l
->nitems
1583 && l
->item
[ind
+1].line
== thisline
+ 1)
1584 *endptr
= l
->item
[ind
+1].pc
;
1586 *endptr
= find_line_pc (symtab
, thisline
+1);
1593 /* Given a line table and a line number, return the index into the line
1594 table for the pc of the nearest line whose number is >= the specified one.
1595 Return -1 if none is found. The value is >= 0 if it is an index.
1597 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
1600 find_line_common (l
, lineno
, exact_match
)
1601 register struct linetable
*l
;
1602 register int lineno
;
1608 /* BEST is the smallest linenumber > LINENO so far seen,
1609 or 0 if none has been seen so far.
1610 BEST_INDEX identifies the item for it. */
1612 int best_index
= -1;
1619 for (i
= 0; i
< len
; i
++)
1621 register struct linetable_entry
*item
= &(l
->item
[i
]);
1623 if (item
->line
== lineno
)
1629 if (item
->line
> lineno
&& (best
== 0 || item
->line
< best
))
1636 /* If we got here, we didn't get an exact match. */
1643 find_pc_line_pc_range (pc
, startptr
, endptr
)
1645 CORE_ADDR
*startptr
, *endptr
;
1647 struct symtab_and_line sal
;
1648 sal
= find_pc_line (pc
, 0);
1651 return sal
.symtab
!= 0;
1654 /* If P is of the form "operator[ \t]+..." where `...' is
1655 some legitimate operator text, return a pointer to the
1656 beginning of the substring of the operator text.
1657 Otherwise, return "". */
1659 operator_chars (p
, end
)
1664 if (strncmp (p
, "operator", 8))
1668 /* Don't get faked out by `operator' being part of a longer
1670 if ((*p
>= 'A' && *p
<= 'Z') || (*p
>= 'a' && *p
<= 'z')
1671 || *p
== '_' || *p
== '$' || *p
== '\0')
1674 /* Allow some whitespace between `operator' and the operator symbol. */
1675 while (*p
== ' ' || *p
== '\t')
1697 if (p
[1] == '=' || p
[1] == p
[0])
1708 error ("`operator ()' must be specified without whitespace in `()'");
1713 error ("`operator ?:' must be specified without whitespace in `?:'");
1718 error ("`operator []' must be specified without whitespace in `[]'");
1722 error ("`operator %s' not supported", p
);
1729 /* Recursive helper function for decode_line_1.
1730 * Look for methods named NAME in type T.
1731 * Return number of matches.
1732 * Put matches in PHYSNAMES and SYM_ARR (which better be big enough!).
1733 * These allocations seem to define "big enough":
1734 * sym_arr = (struct symbol **) alloca(TYPE_NFN_FIELDS_TOTAL (t) * sizeof(struct symbol*));
1735 * physnames = (char **) alloca (TYPE_NFN_FIELDS_TOTAL (t) * sizeof(char*));
1739 find_methods(t
, name
, physnames
, sym_arr
)
1743 struct symbol
**sym_arr
;
1747 struct symbol
*sym_class
;
1748 char *class_name
= type_name_no_tag (t
);
1749 /* Ignore this class if it doesn't have a name.
1750 This prevents core dumps, but is just a workaround
1751 because we might not find the function in
1752 certain cases, such as
1753 struct D {virtual int f();}
1754 struct C : D {virtual int g();}
1755 (in this case g++ 1.35.1- does not put out a name
1756 for D as such, it defines type 19 (for example) in
1757 the same stab as C, and then does a
1758 .stabs "D:T19" and a .stabs "D:t19".
1760 "break C::f" should not be looking for field f in
1762 but just for the field f in the baseclasses of C
1763 (no matter what their names).
1765 However, I don't know how to replace the code below
1766 that depends on knowing the name of D. */
1768 && (sym_class
= lookup_symbol (class_name
,
1769 (struct block
*)NULL
,
1772 (struct symtab
**)NULL
)))
1775 t
= SYMBOL_TYPE (sym_class
);
1776 for (method_counter
= TYPE_NFN_FIELDS (t
) - 1;
1777 method_counter
>= 0;
1781 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, method_counter
);
1783 char *method_name
= TYPE_FN_FIELDLIST_NAME (t
, method_counter
);
1784 if (!strcmp (name
, method_name
))
1785 /* Find all the fields with that name. */
1786 for (field_counter
= TYPE_FN_FIELDLIST_LENGTH (t
, method_counter
) - 1;
1791 if (TYPE_FLAGS (TYPE_FN_FIELD_TYPE (f
, field_counter
)) & TYPE_FLAG_STUB
)
1792 check_stub_method (t
, method_counter
, field_counter
);
1793 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, field_counter
);
1794 physnames
[i1
] = (char*) alloca (strlen (phys_name
) + 1);
1795 strcpy (physnames
[i1
], phys_name
);
1796 sym_arr
[i1
] = lookup_symbol (phys_name
,
1797 SYMBOL_BLOCK_VALUE (sym_class
),
1800 (struct symtab
**) NULL
);
1801 if (sym_arr
[i1
]) i1
++;
1805 /* Only search baseclasses if there is no match yet,
1806 * since names in derived classes override those in baseclasses.
1810 for (ibase
= 0; ibase
< TYPE_N_BASECLASSES (t
); ibase
++)
1811 i1
+= find_methods(TYPE_BASECLASS(t
, ibase
), name
,
1812 physnames
+ i1
, sym_arr
+ i1
);
1816 /* Parse a string that specifies a line number.
1817 Pass the address of a char * variable; that variable will be
1818 advanced over the characters actually parsed.
1822 LINENUM -- that line number in current file. PC returned is 0.
1823 FILE:LINENUM -- that line in that file. PC returned is 0.
1824 FUNCTION -- line number of openbrace of that function.
1825 PC returned is the start of the function.
1826 VARIABLE -- line number of definition of that variable.
1828 FILE:FUNCTION -- likewise, but prefer functions in that file.
1829 *EXPR -- line in which address EXPR appears.
1831 FUNCTION may be an undebuggable function found in misc_function_vector.
1833 If the argument FUNFIRSTLINE is nonzero, we want the first line
1834 of real code inside a function when a function is specified.
1836 DEFAULT_SYMTAB specifies the file to use if none is specified.
1837 It defaults to current_source_symtab.
1838 DEFAULT_LINE specifies the line number to use for relative
1839 line numbers (that start with signs). Defaults to current_source_line.
1841 Note that it is possible to return zero for the symtab
1842 if no file is validly specified. Callers must check that.
1843 Also, the line number returned may be invalid. */
1845 struct symtabs_and_lines
1846 decode_line_1 (argptr
, funfirstline
, default_symtab
, default_line
)
1849 struct symtab
*default_symtab
;
1852 struct symtabs_and_lines
decode_line_2 ();
1853 struct symtabs_and_lines values
;
1854 struct symtab_and_line val
;
1855 register char *p
, *p1
;
1857 register struct symtab
*s
;
1859 register struct symbol
*sym
;
1860 /* The symtab that SYM was found in. */
1861 struct symtab
*sym_symtab
;
1863 register CORE_ADDR pc
;
1866 struct symbol
*sym_class
;
1868 struct symbol
**sym_arr
;
1872 /* Defaults have defaults. */
1874 if (default_symtab
== 0)
1876 default_symtab
= current_source_symtab
;
1877 default_line
= current_source_line
;
1880 /* See if arg is *PC */
1882 if (**argptr
== '*')
1885 pc
= parse_and_eval_address_1 (argptr
);
1886 values
.sals
= (struct symtab_and_line
*)
1887 xmalloc (sizeof (struct symtab_and_line
));
1889 values
.sals
[0] = find_pc_line (pc
, 0);
1890 values
.sals
[0].pc
= pc
;
1894 /* Maybe arg is FILE : LINENUM or FILE : FUNCTION */
1898 for (p
= *argptr
; *p
; p
++)
1900 if (p
[0] == ':' || p
[0] == ' ' || p
[0] == '\t')
1903 while (p
[0] == ' ' || p
[0] == '\t') p
++;
1905 q
= operator_chars (*argptr
, &q1
);
1912 /* Extract the class name. */
1914 while (p
!= *argptr
&& p
[-1] == ' ') --p
;
1915 copy
= (char *) alloca (p
- *argptr
+ 1);
1916 bcopy (*argptr
, copy
, p
- *argptr
);
1917 copy
[p
- *argptr
] = 0;
1919 /* Discard the class name from the arg. */
1921 while (*p
== ' ' || *p
== '\t') p
++;
1924 sym_class
= lookup_symbol (copy
, 0, STRUCT_NAMESPACE
, 0,
1925 (struct symtab
**)NULL
);
1928 (TYPE_CODE (SYMBOL_TYPE (sym_class
)) == TYPE_CODE_STRUCT
1929 || TYPE_CODE (SYMBOL_TYPE (sym_class
)) == TYPE_CODE_UNION
))
1931 /* Arg token is not digits => try it as a function name
1932 Find the next token (everything up to end or next whitespace). */
1934 while (*p
&& *p
!= ' ' && *p
!= '\t' && *p
!= ',' && *p
!=':') p
++;
1935 q
= operator_chars (*argptr
, &q1
);
1937 copy
= (char *) alloca (p
- *argptr
+ 1 + (q1
- q
));
1942 copy
[2] = CPLUS_MARKER
;
1943 bcopy (q
, copy
+ 3, q1
- q
);
1944 copy
[3 + (q1
- q
)] = '\0';
1949 bcopy (*argptr
, copy
, p
- *argptr
);
1950 copy
[p
- *argptr
] = '\0';
1953 /* no line number may be specified */
1954 while (*p
== ' ' || *p
== '\t') p
++;
1958 i1
= 0; /* counter for the symbol array */
1959 t
= SYMBOL_TYPE (sym_class
);
1960 sym_arr
= (struct symbol
**) alloca(TYPE_NFN_FIELDS_TOTAL (t
) * sizeof(struct symbol
*));
1961 physnames
= (char **) alloca (TYPE_NFN_FIELDS_TOTAL (t
) * sizeof(char*));
1963 if (destructor_name_p (copy
, t
))
1965 /* destructors are a special case. */
1966 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, 0);
1967 int len
= TYPE_FN_FIELDLIST_LENGTH (t
, 0) - 1;
1968 char *phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, len
);
1969 physnames
[i1
] = (char *)alloca (strlen (phys_name
) + 1);
1970 strcpy (physnames
[i1
], phys_name
);
1972 lookup_symbol (phys_name
, SYMBOL_BLOCK_VALUE (sym_class
),
1973 VAR_NAMESPACE
, 0, (struct symtab
**)NULL
);
1974 if (sym_arr
[i1
]) i1
++;
1977 i1
= find_methods (t
, copy
, physnames
, sym_arr
);
1980 /* There is exactly one field with that name. */
1983 if (sym
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
)
1985 /* Arg is the name of a function */
1986 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) + FUNCTION_START_OFFSET
;
1989 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
1991 values
.sals
[0] = find_pc_line (pc
, 0);
1992 values
.sals
[0].pc
= (values
.sals
[0].end
&& values
.sals
[0].pc
!= pc
) ? values
.sals
[0].end
: pc
;
2002 /* There is more than one field with that name
2003 (overloaded). Ask the user which one to use. */
2004 return decode_line_2 (sym_arr
, i1
, funfirstline
);
2010 if (OPNAME_PREFIX_P (copy
))
2012 tmp
= (char *)alloca (strlen (copy
+3) + 9);
2013 strcpy (tmp
, "operator ");
2014 strcat (tmp
, copy
+3);
2018 error ("that class does not have any method named %s", tmp
);
2022 /* The quotes are important if copy is empty. */
2023 error("No class, struct, or union named \"%s\"", copy
);
2028 /* Extract the file name. */
2030 while (p
!= *argptr
&& p
[-1] == ' ') --p
;
2031 copy
= (char *) alloca (p
- *argptr
+ 1 + (q1
- q
));
2036 copy
[2] = CPLUS_MARKER
;
2037 bcopy (q
, copy
+ 3, q1
-q
);
2038 copy
[3 + (q1
-q
)] = 0;
2043 bcopy (*argptr
, copy
, p
- *argptr
);
2044 copy
[p
- *argptr
] = 0;
2047 /* Find that file's data. */
2048 s
= lookup_symtab (copy
);
2051 if (symtab_list
== 0 && partial_symtab_list
== 0)
2052 error (no_symtab_msg
);
2053 error ("No source file named %s.", copy
);
2056 /* Discard the file name from the arg. */
2058 while (*p
== ' ' || *p
== '\t') p
++;
2062 /* S is specified file's symtab, or 0 if no file specified.
2063 arg no longer contains the file name. */
2065 /* Check whether arg is all digits (and sign) */
2068 if (*p
== '-' || *p
== '+') p
++;
2069 while (*p
>= '0' && *p
<= '9')
2072 if (p
!= *argptr
&& (*p
== 0 || *p
== ' ' || *p
== '\t' || *p
== ','))
2074 /* We found a token consisting of all digits -- at least one digit. */
2075 enum sign
{none
, plus
, minus
} sign
= none
;
2077 /* This is where we need to make sure that we have good defaults.
2078 We must guarantee that this section of code is never executed
2079 when we are called with just a function name, since
2080 select_source_symtab calls us with such an argument */
2082 if (s
== 0 && default_symtab
== 0)
2084 select_source_symtab (0);
2085 default_symtab
= current_source_symtab
;
2086 default_line
= current_source_line
;
2089 if (**argptr
== '+')
2090 sign
= plus
, (*argptr
)++;
2091 else if (**argptr
== '-')
2092 sign
= minus
, (*argptr
)++;
2093 val
.line
= atoi (*argptr
);
2100 val
.line
= default_line
+ val
.line
;
2106 val
.line
= default_line
- val
.line
;
2111 break; /* No need to adjust val.line. */
2114 while (*p
== ' ' || *p
== '\t') p
++;
2120 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
2121 values
.sals
[0] = val
;
2126 /* Arg token is not digits => try it as a variable name
2127 Find the next token (everything up to end or next whitespace). */
2129 while (*p
&& *p
!= ' ' && *p
!= '\t' && *p
!= ',') p
++;
2130 copy
= (char *) alloca (p
- *argptr
+ 1);
2131 bcopy (*argptr
, copy
, p
- *argptr
);
2132 copy
[p
- *argptr
] = 0;
2133 while (*p
== ' ' || *p
== '\t') p
++;
2136 /* Look up that token as a variable.
2137 If file specified, use that file's per-file block to start with. */
2139 sym
= lookup_symbol (copy
,
2140 (s
? BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)
2141 : get_selected_block ()),
2142 VAR_NAMESPACE
, 0, &sym_symtab
);
2146 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2148 /* Arg is the name of a function */
2149 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) + FUNCTION_START_OFFSET
;
2152 val
= find_pc_line (pc
, 0);
2153 #ifdef PROLOGUE_FIRSTLINE_OVERLAP
2154 /* Convex: no need to suppress code on first line, if any */
2157 val
.pc
= (val
.end
&& val
.pc
!= pc
) ? val
.end
: pc
;
2159 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
2160 values
.sals
[0] = val
;
2163 /* I think this is always the same as the line that
2164 we calculate above, but the general principle is
2165 "trust the symbols more than stuff like
2167 if (SYMBOL_LINE (sym
) != 0)
2168 values
.sals
[0].line
= SYMBOL_LINE (sym
);
2172 else if (SYMBOL_LINE (sym
) != 0)
2174 /* We know its line number. */
2175 values
.sals
= (struct symtab_and_line
*)
2176 xmalloc (sizeof (struct symtab_and_line
));
2178 bzero (&values
.sals
[0], sizeof (values
.sals
[0]));
2179 values
.sals
[0].symtab
= sym_symtab
;
2180 values
.sals
[0].line
= SYMBOL_LINE (sym
);
2184 /* This can happen if it is compiled with a compiler which doesn't
2185 put out line numbers for variables. */
2186 error ("Line number not known for symbol \"%s\"", copy
);
2189 if ((i
= lookup_misc_func (copy
)) >= 0)
2193 val
.pc
= misc_function_vector
[i
].address
+ FUNCTION_START_OFFSET
;
2195 SKIP_PROLOGUE (val
.pc
);
2196 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
2197 values
.sals
[0] = val
;
2202 if (symtab_list
== 0 && partial_symtab_list
== 0 && misc_function_count
== 0)
2203 error (no_symtab_msg
);
2205 error ("Function %s not defined.", copy
);
2206 return values
; /* for lint */
2209 struct symtabs_and_lines
2210 decode_line_spec (string
, funfirstline
)
2214 struct symtabs_and_lines sals
;
2216 error ("Empty line specification.");
2217 sals
= decode_line_1 (&string
, funfirstline
,
2218 current_source_symtab
, current_source_line
);
2220 error ("Junk at end of line specification: %s", string
);
2224 /* Given a list of NELTS symbols in sym_arr (with corresponding
2225 mangled names in physnames), return a list of lines to operate on
2226 (ask user if necessary). */
2227 struct symtabs_and_lines
2228 decode_line_2 (sym_arr
, nelts
, funfirstline
)
2229 struct symbol
*sym_arr
[];
2233 struct symtabs_and_lines values
, return_values
;
2234 register CORE_ADDR pc
;
2235 char *args
, *arg1
, *command_line_input ();
2239 values
.sals
= (struct symtab_and_line
*) alloca (nelts
* sizeof(struct symtab_and_line
));
2240 return_values
.sals
= (struct symtab_and_line
*) xmalloc (nelts
* sizeof(struct symtab_and_line
));
2243 printf("[0] cancel\n[1] all\n");
2246 if (sym_arr
[i
] && SYMBOL_CLASS (sym_arr
[i
]) == LOC_BLOCK
)
2248 /* Arg is the name of a function */
2249 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym_arr
[i
]))
2250 + FUNCTION_START_OFFSET
;
2253 values
.sals
[i
] = find_pc_line (pc
, 0);
2254 values
.sals
[i
].pc
= (values
.sals
[i
].end
&& values
.sals
[i
].pc
!= pc
) ?
2255 values
.sals
[i
].end
: pc
;
2256 printf("[%d] file:%s; line number:%d\n",
2257 (i
+2), values
.sals
[i
].symtab
->filename
, values
.sals
[i
].line
);
2259 else printf ("?HERE\n");
2263 if ((prompt
= getenv ("PS2")) == NULL
)
2267 printf("%s ",prompt
);
2270 args
= command_line_input (0, 0);
2273 error_no_arg ("one or more choice numbers");
2281 while (*arg1
>= '0' && *arg1
<= '9') arg1
++;
2282 if (*arg1
&& *arg1
!= ' ' && *arg1
!= '\t')
2283 error ("Arguments must be choice numbers.");
2288 error ("cancelled");
2291 bcopy (values
.sals
, return_values
.sals
, (nelts
* sizeof(struct symtab_and_line
)));
2292 return_values
.nelts
= nelts
;
2293 return return_values
;
2296 if (num
> nelts
+ 2)
2298 printf ("No choice number %d.\n", num
);
2303 if (values
.sals
[num
].pc
)
2305 return_values
.sals
[i
++] = values
.sals
[num
];
2306 values
.sals
[num
].pc
= 0;
2310 printf ("duplicate request for %d ignored.\n", num
);
2315 while (*args
== ' ' || *args
== '\t') args
++;
2317 return_values
.nelts
= i
;
2318 return return_values
;
2321 /* Return the index of misc function named NAME. */
2324 lookup_misc_func (name
)
2325 register char *name
;
2329 for (i
= 0; i
< misc_function_count
; i
++)
2330 if (!strcmp (misc_function_vector
[i
].name
, name
))
2332 return -1; /* not found */
2335 /* Slave routine for sources_info. Force line breaks at ,'s.
2336 NAME is the name to print and *FIRST is nonzero if this is the first
2337 name printed. Set *FIRST to zero. */
2339 output_source_filename (name
, first
)
2344 /* Table of files printed so far. Since a single source file can
2345 result in several partial symbol tables, we need to avoid printing
2346 it more than once. Note: if some of the psymtabs are read in and
2347 some are not, it gets printed both under "Source files for which
2348 symbols have been read" and "Source files for which symbols will
2349 be read in on demand". I consider this a reasonable way to deal
2350 with the situation. I'm not sure whether this can also happen for
2351 symtabs; it doesn't hurt to check. */
2352 static char **tab
= NULL
;
2353 /* Allocated size of tab in elements.
2354 Start with one 256-byte block (when using GNU malloc.c).
2355 24 is the malloc overhead when range checking is in effect. */
2356 static int tab_alloc_size
= (256 - 24) / sizeof (char *);
2357 /* Current size of tab in elements. */
2358 static int tab_cur_size
;
2365 tab
= (char **) xmalloc (tab_alloc_size
* sizeof (*tab
));
2369 /* Is NAME in tab? */
2370 for (p
= tab
; p
< tab
+ tab_cur_size
; p
++)
2371 if (strcmp (*p
, name
) == 0)
2372 /* Yes; don't print it again. */
2374 /* No; add it to tab. */
2375 if (tab_cur_size
== tab_alloc_size
)
2377 tab_alloc_size
*= 2;
2378 tab
= (char **) xrealloc (tab
, tab_alloc_size
* sizeof (*tab
));
2380 tab
[tab_cur_size
++] = name
;
2389 printf_filtered (",");
2393 if (column
!= 0 && column
+ strlen (name
) >= 70)
2395 printf_filtered ("\n");
2398 else if (column
!= 0)
2400 printf_filtered (" ");
2403 fputs_filtered (name
, stdout
);
2404 column
+= strlen (name
);
2410 register struct symtab
*s
;
2411 register struct partial_symtab
*ps
;
2414 if (symtab_list
== 0 && partial_symtab_list
== 0)
2416 printf (no_symtab_msg
);
2420 printf_filtered ("Source files for which symbols have been read in:\n\n");
2423 for (s
= symtab_list
; s
; s
= s
->next
)
2424 output_source_filename (s
->filename
, &first
);
2425 printf_filtered ("\n\n");
2427 printf_filtered ("Source files for which symbols will be read in on demand:\n\n");
2430 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
2432 output_source_filename (ps
->filename
, &first
);
2433 printf_filtered ("\n");
2436 /* List all symbols (if REGEXP is 0) or all symbols matching REGEXP.
2437 If CLASS is zero, list all symbols except functions and type names.
2438 If CLASS is 1, list only functions.
2439 If CLASS is 2, list only type names.
2440 If CLASS is 3, list only method names.
2442 BPT is non-zero if we should set a breakpoint at the functions
2446 list_symbols (regexp
, class, bpt
)
2451 register struct symtab
*s
;
2452 register struct partial_symtab
*ps
;
2453 register struct blockvector
*bv
;
2454 struct blockvector
*prev_bv
= 0;
2455 register struct block
*b
;
2457 register struct symbol
*sym
;
2458 struct partial_symbol
*psym
;
2460 static char *classnames
[]
2461 = {"variable", "function", "type", "method"};
2462 int found_in_file
= 0;
2464 static enum misc_function_type types
[]
2465 = {mf_data
, mf_text
, mf_abs
, mf_unknown
};
2466 static enum misc_function_type types2
[]
2467 = {mf_bss
, mf_text
, mf_abs
, mf_unknown
};
2468 enum misc_function_type ourtype
= types
[class];
2469 enum misc_function_type ourtype2
= types2
[class];
2472 if (0 != (val
= re_comp (regexp
)))
2473 error ("Invalid regexp (%s): %s", val
, regexp
);
2475 /* Search through the partial_symtab_list *first* for all symbols
2476 matching the regexp. That way we don't have to reproduce all of
2477 the machinery below. */
2478 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
2480 struct partial_symbol
*bound
, *gbound
, *sbound
;
2483 if (ps
->readin
) continue;
2485 gbound
= global_psymbols
.list
+ ps
->globals_offset
+ ps
->n_global_syms
;
2486 sbound
= static_psymbols
.list
+ ps
->statics_offset
+ ps
->n_static_syms
;
2489 /* Go through all of the symbols stored in a partial
2490 symtab in one loop. */
2491 psym
= global_psymbols
.list
+ ps
->globals_offset
;
2496 if (bound
== gbound
&& ps
->n_static_syms
!= 0)
2498 psym
= static_psymbols
.list
+ ps
->statics_offset
;
2509 /* If it would match (logic taken from loop below)
2510 load the file and go on to the next one */
2511 if ((regexp
== 0 || re_exec (SYMBOL_NAME (psym
)))
2512 && ((class == 0 && SYMBOL_CLASS (psym
) != LOC_TYPEDEF
2513 && SYMBOL_CLASS (psym
) != LOC_BLOCK
)
2514 || (class == 1 && SYMBOL_CLASS (psym
) == LOC_BLOCK
)
2515 || (class == 2 && SYMBOL_CLASS (psym
) == LOC_TYPEDEF
)
2516 || (class == 3 && SYMBOL_CLASS (psym
) == LOC_BLOCK
)))
2518 (void) PSYMTAB_TO_SYMTAB(ps
);
2526 /* Here, we search through the misc function vector for functions that
2527 match, and call find_pc_symtab on them to force their symbols to
2528 be read. The symbol will then be found during the scan of symtabs
2529 below. If find_pc_symtab fails, set found_misc so that we will
2530 rescan to print any matching symbols without debug info. */
2533 for (i
= 0; i
< misc_function_count
; i
++) {
2534 if (misc_function_vector
[i
].type
!= ourtype
2535 && misc_function_vector
[i
].type
!= ourtype2
)
2537 if (regexp
== 0 || re_exec (misc_function_vector
[i
].name
)) {
2538 if (0 == find_pc_symtab (misc_function_vector
[i
].address
))
2544 /* Printout here so as to get after the "Reading in symbols"
2545 messages which will be generated above. */
2547 printf_filtered (regexp
2548 ? "All %ss matching regular expression \"%s\":\n"
2549 : "All defined %ss:\n",
2553 for (s
= symtab_list
; s
; s
= s
->next
)
2556 bv
= BLOCKVECTOR (s
);
2557 /* Often many files share a blockvector.
2558 Scan each blockvector only once so that
2559 we don't get every symbol many times.
2560 It happens that the first symtab in the list
2561 for any given blockvector is the main file. */
2563 for (i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; i
++)
2565 b
= BLOCKVECTOR_BLOCK (bv
, i
);
2566 /* Skip the sort if this block is always sorted. */
2567 if (!BLOCK_SHOULD_SORT (b
))
2568 sort_block_syms (b
);
2569 for (j
= 0; j
< BLOCK_NSYMS (b
); j
++)
2572 sym
= BLOCK_SYM (b
, j
);
2573 if ((regexp
== 0 || re_exec (SYMBOL_NAME (sym
)))
2574 && ((class == 0 && SYMBOL_CLASS (sym
) != LOC_TYPEDEF
2575 && SYMBOL_CLASS (sym
) != LOC_BLOCK
)
2576 || (class == 1 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2577 || (class == 2 && SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
2578 || (class == 3 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)))
2582 /* Set a breakpoint here, if it's a function */
2584 break_command (SYMBOL_NAME(sym
), 0);
2586 else if (!found_in_file
)
2588 fputs_filtered ("\nFile ", stdout
);
2589 fputs_filtered (s
->filename
, stdout
);
2590 fputs_filtered (":\n", stdout
);
2594 if (class != 2 && i
== STATIC_BLOCK
)
2595 printf_filtered ("static ");
2597 /* Typedef that is not a C++ class */
2599 && SYMBOL_NAMESPACE (sym
) != STRUCT_NAMESPACE
)
2601 /* We haven't integrated this from A. Beers yet */
2602 error ("typedef_print(SYMBOL_TYPE(sym),sym,stdout);");
2604 typedef_print(SYMBOL_TYPE(sym
),sym
,stdout
);
2606 /* variable, func, or typedef-that-is-c++-class */
2607 else if (class < 2 ||
2609 SYMBOL_NAMESPACE(sym
) == STRUCT_NAMESPACE
))
2611 type_print (SYMBOL_TYPE (sym
),
2612 (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
2613 ? "" : SYMBOL_NAME (sym
)),
2616 printf_filtered (";\n");
2622 type_print_base (TYPE_FN_FIELD_TYPE(t
, i
), stdout
, 0, 0);
2623 type_print_varspec_prefix (TYPE_FN_FIELD_TYPE(t
, i
), stdout
, 0);
2624 sprintf (buf
, " %s::", type_name_no_tag (t
));
2625 type_print_method_args (TYPE_FN_FIELD_ARGS (t
, i
), buf
, name
, stdout
);
2635 /* If there are no eyes, avoid all contact. I mean, if there are
2636 no debug symbols, then print directly from the misc_function_vector. */
2638 if (found_misc
|| class != 1) {
2640 for (i
= 0; i
< misc_function_count
; i
++) {
2641 if (misc_function_vector
[i
].type
!= ourtype
2642 && misc_function_vector
[i
].type
!= ourtype2
)
2644 if (regexp
== 0 || re_exec (misc_function_vector
[i
].name
)) {
2645 /* Functions: Look up by address. */
2647 if (0 != find_pc_symtab (misc_function_vector
[i
].address
))
2649 /* Variables/Absolutes: Look up by name */
2650 if (0 != lookup_symbol (misc_function_vector
[i
].name
,
2651 (struct block
*)0, VAR_NAMESPACE
, 0, (struct symtab
**)0))
2653 if (!found_in_file
) {
2654 printf_filtered ("\nNon-debugging symbols:\n");
2657 printf_filtered (" %08x %s\n",
2658 misc_function_vector
[i
].address
,
2659 misc_function_vector
[i
].name
);
2666 variables_info (regexp
)
2669 list_symbols (regexp
, 0, 0);
2673 functions_info (regexp
)
2676 list_symbols (regexp
, 1, 0);
2683 list_symbols (regexp
, 2, 0);
2687 /* Tiemann says: "info methods was never implemented." */
2689 methods_info (regexp
)
2692 list_symbols (regexp
, 3, 0);
2696 /* Breakpoint all functions matching regular expression. */
2698 rbreak_command (regexp
)
2701 list_symbols (regexp
, 1, 1);
2704 /* Helper function to initialize the standard scalar types. */
2707 init_type (code
, length
, uns
, name
)
2708 enum type_code code
;
2712 register struct type
*type
;
2714 type
= (struct type
*) xmalloc (sizeof (struct type
));
2715 bzero (type
, sizeof *type
);
2716 TYPE_MAIN_VARIANT (type
) = type
;
2717 TYPE_CODE (type
) = code
;
2718 TYPE_LENGTH (type
) = length
;
2719 TYPE_FLAGS (type
) = uns
? TYPE_FLAG_UNSIGNED
: 0;
2720 TYPE_FLAGS (type
) |= TYPE_FLAG_PERM
;
2721 TYPE_NFIELDS (type
) = 0;
2722 TYPE_NAME (type
) = name
;
2725 TYPE_NFN_FIELDS (type
) = 0;
2726 TYPE_N_BASECLASSES (type
) = 0;
2730 /* Return Nonzero if block a is lexically nested within block b,
2731 or if a and b have the same pc range.
2732 Return zero otherwise. */
2735 struct block
*a
, *b
;
2739 return BLOCK_START (a
) >= BLOCK_START (b
)
2740 && BLOCK_END (a
) <= BLOCK_END (b
);
2744 /* Helper routine for make_symbol_completion_list. */
2746 int return_val_size
, return_val_index
;
2750 completion_list_add_symbol (symname
)
2753 if (return_val_index
+ 3 > return_val_size
)
2755 (char **)xrealloc (return_val
,
2756 (return_val_size
*= 2) * sizeof (char *));
2758 return_val
[return_val_index
] =
2759 (char *)xmalloc (1 + strlen (symname
));
2761 strcpy (return_val
[return_val_index
], symname
);
2763 return_val
[++return_val_index
] = (char *)NULL
;
2766 /* Return a NULL terminated array of all symbols (regardless of class) which
2767 begin by matching TEXT. If the answer is no symbols, then the return value
2768 is an array which contains only a NULL pointer.
2770 Problem: All of the symbols have to be copied because readline
2771 frees them. I'm not going to worry about this; hopefully there
2772 won't be that many. */
2775 make_symbol_completion_list (text
)
2778 register struct symtab
*s
;
2779 register struct partial_symtab
*ps
;
2780 register struct block
*b
, *surrounding_static_block
= 0;
2781 extern struct block
*get_selected_block ();
2783 struct partial_symbol
*psym
;
2785 int text_len
= strlen (text
);
2786 return_val_size
= 100;
2787 return_val_index
= 0;
2789 (char **)xmalloc ((1 + return_val_size
) *sizeof (char *));
2790 return_val
[0] = (char *)NULL
;
2792 /* Look through the partial symtabs for all symbols which begin
2793 by matching TEXT. Add each one that you find to the list. */
2795 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
2797 /* If the psymtab's been read in we'll get it when we search
2798 through the blockvector. */
2799 if (ps
->readin
) continue;
2801 for (psym
= global_psymbols
.list
+ ps
->globals_offset
;
2802 psym
< (global_psymbols
.list
+ ps
->globals_offset
2803 + ps
->n_global_syms
);
2806 QUIT
; /* If interrupted, then quit. */
2807 if ((strncmp (SYMBOL_NAME (psym
), text
, text_len
) == 0))
2808 completion_list_add_symbol (SYMBOL_NAME (psym
));
2811 for (psym
= static_psymbols
.list
+ ps
->statics_offset
;
2812 psym
< (static_psymbols
.list
+ ps
->statics_offset
2813 + ps
->n_static_syms
);
2817 if ((strncmp (SYMBOL_NAME (psym
), text
, text_len
) == 0))
2818 completion_list_add_symbol (SYMBOL_NAME (psym
));
2822 /* At this point scan through the misc function vector and add each
2823 symbol you find to the list. Eventually we want to ignore
2824 anything that isn't a text symbol (everything else will be
2825 handled by the psymtab code above). */
2827 for (i
= 0; i
< misc_function_count
; i
++)
2828 if (!strncmp (text
, misc_function_vector
[i
].name
, text_len
))
2829 completion_list_add_symbol (misc_function_vector
[i
].name
);
2831 /* Search upwards from currently selected frame (so that we can
2832 complete on local vars. */
2833 for (b
= get_selected_block (); b
; b
= BLOCK_SUPERBLOCK (b
))
2835 if (!BLOCK_SUPERBLOCK (b
))
2836 surrounding_static_block
= b
; /* For elmin of dups */
2838 /* Also catch fields of types defined in this places which
2839 match our text string. Only complete on types visible
2840 from current context. */
2841 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2843 register struct symbol
*sym
= BLOCK_SYM (b
, i
);
2845 if (!strncmp (SYMBOL_NAME (sym
), text
, text_len
))
2846 completion_list_add_symbol (SYMBOL_NAME (sym
));
2848 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
2850 struct type
*t
= SYMBOL_TYPE (sym
);
2851 enum type_code c
= TYPE_CODE (t
);
2853 if (c
== TYPE_CODE_UNION
|| c
== TYPE_CODE_STRUCT
)
2854 for (j
= TYPE_N_BASECLASSES (t
); j
< TYPE_NFIELDS (t
); j
++)
2855 if (TYPE_FIELD_NAME (t
, j
) &&
2856 !strncmp (TYPE_FIELD_NAME (t
, j
), text
, text_len
))
2857 completion_list_add_symbol (TYPE_FIELD_NAME (t
, j
));
2862 /* Go through the symtabs and check the externs and statics for
2863 symbols which match. */
2865 for (s
= symtab_list
; s
; s
= s
->next
)
2867 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
2869 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2870 if (!strncmp (SYMBOL_NAME (BLOCK_SYM (b
, i
)), text
, text_len
))
2871 completion_list_add_symbol (SYMBOL_NAME (BLOCK_SYM (b
, i
)));
2874 for (s
= symtab_list
; s
; s
= s
->next
)
2876 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
2878 /* Don't do this block twice. */
2879 if (b
== surrounding_static_block
) continue;
2881 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2882 if (!strncmp (SYMBOL_NAME (BLOCK_SYM (b
, i
)), text
, text_len
))
2883 completion_list_add_symbol (SYMBOL_NAME (BLOCK_SYM (b
, i
)));
2886 return (return_val
);
2890 /* Add the type of the symbol sym to the type of the current
2891 function whose block we are in (assumed). The type of
2892 this current function is contained in *TYPE.
2894 This basically works as follows: When we find a function
2895 symbol (N_FUNC with a 'f' or 'F' in the symbol name), we record
2896 a pointer to its type in the global in_function_type. Every
2897 time we come across a parameter symbol ('p' in its name), then
2898 this procedure adds the name and type of that parameter
2899 to the function type pointed to by *TYPE. (Which should correspond
2900 to in_function_type if it was called correctly).
2902 Note that since we are modifying a type, the result of
2903 lookup_function_type() should be bcopy()ed before calling
2904 this. When not in strict typing mode, the expression
2905 evaluator can choose to ignore this.
2907 Assumption: All of a function's parameter symbols will
2908 appear before another function symbol is found. The parameters
2909 appear in the same order in the argument list as they do in the
2913 add_param_to_type (type
,sym
)
2917 int num
= ++(TYPE_NFIELDS(*type
));
2919 if(TYPE_NFIELDS(*type
)-1)
2920 TYPE_FIELDS(*type
) =
2921 (struct field
*)xrealloc((char *)(TYPE_FIELDS(*type
)),
2922 num
*sizeof(struct field
));
2924 TYPE_FIELDS(*type
) =
2925 (struct field
*)xmalloc(num
*sizeof(struct field
));
2927 TYPE_FIELD_BITPOS(*type
,num
-1) = num
-1;
2928 TYPE_FIELD_BITSIZE(*type
,num
-1) = 0;
2929 TYPE_FIELD_TYPE(*type
,num
-1) = SYMBOL_TYPE(sym
);
2930 TYPE_FIELD_NAME(*type
,num
-1) = SYMBOL_NAME(sym
);
2935 _initialize_symtab ()
2937 add_info ("variables", variables_info
,
2938 "All global and static variable names, or those matching REGEXP.");
2939 add_info ("functions", functions_info
,
2940 "All function names, or those matching REGEXP.");
2942 /* FIXME: This command has at least the following problems:
2943 1. It prints builtin types (in a very strange and confusing fashion).
2944 2. It doesn't print right, e.g. with
2945 typedef struct foo *FOO
2946 type_print prints "FOO" when we want to make it (in this situation)
2947 print "struct foo *".
2948 I also think "ptype" or "whatis" is more likely to be useful (but if
2949 there is much disagreement "info types" can be fixed). */
2950 add_info ("types", types_info
,
2951 "All types names, or those matching REGEXP.");
2954 add_info ("methods", methods_info
,
2955 "All method names, or those matching REGEXP::REGEXP.\n\
2956 If the class qualifier is ommited, it is assumed to be the current scope.\n\
2957 If the first REGEXP is ommited, then all methods matching the second REGEXP\n\
2960 add_info ("sources", sources_info
,
2961 "Source files in the program.");
2963 add_com ("rbreak", no_class
, rbreak_command
,
2964 "Set a breakpoint for all functions matching REGEXP.");
2966 /* Initialize the one built-in type that isn't language dependent... */
2967 builtin_type_error
= init_type (TYPE_CODE_ERROR
, 0, 0, "<unknown type>");