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 char *cplus_mangle_opname ();
45 extern struct value
*value_of_this ();
46 extern void break_command ();
47 extern void select_source_symtab ();
49 /* Functions this file defines */
50 static int find_line_common ();
51 struct partial_symtab
*lookup_partial_symtab ();
52 static struct partial_symbol
*lookup_partial_symbol ();
53 static struct partial_symbol
*lookup_demangled_partial_symbol ();
54 static struct symbol
*lookup_demangled_block_symbol ();
56 /* The single non-language-specific builtin type */
57 struct type
*builtin_type_error
;
59 /* Block in which the most recently searched-for symbol was found.
60 Might be better to make this a parameter to lookup_symbol and
62 struct block
*block_found
;
64 char no_symtab_msg
[] = "No symbol table is loaded. Use the \"file\" command.";
66 /* Check for a symtab of a specific name; first in symtabs, then in
67 psymtabs. *If* there is no '/' in the name, a match after a '/'
68 in the symtab filename will also work. */
70 static struct symtab
*
71 lookup_symtab_1 (name
)
74 register struct symtab
*s
;
75 register struct partial_symtab
*ps
;
76 register char *slash
= strchr (name
, '/');
77 register int len
= strlen (name
);
79 for (s
= symtab_list
; s
; s
= s
->next
)
80 if (!strcmp (name
, s
->filename
))
83 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
84 if (!strcmp (name
, ps
->filename
))
87 error ("Internal: readin pst for `%s' found when no symtab found.", name
);
88 return PSYMTAB_TO_SYMTAB (ps
);
93 for (s
= symtab_list
; s
; s
= s
->next
)
95 int l
= strlen (s
->filename
);
97 if (s
->filename
[l
- len
-1] == '/'
98 && !strcmp (s
->filename
+ l
- len
, name
))
102 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
104 int l
= strlen (ps
->filename
);
106 if (ps
->filename
[l
- len
- 1] == '/'
107 && !strcmp (ps
->filename
+ l
- len
, name
))
110 error ("Internal: readin pst for `%s' found when no symtab found.", name
);
111 return PSYMTAB_TO_SYMTAB (ps
);
118 /* Lookup the symbol table of a source file named NAME. Try a couple
119 of variations if the first lookup doesn't work. */
125 register struct symtab
*s
;
128 s
= lookup_symtab_1 (name
);
131 /* If name not found as specified, see if adding ".c" helps. */
133 copy
= (char *) alloca (strlen (name
) + 3);
136 s
= lookup_symtab_1 (copy
);
139 /* We didn't find anything; die. */
143 /* Lookup the partial symbol table of a source file named NAME. This
144 only returns true on an exact match (ie. this semantics are
145 different from lookup_symtab. */
147 struct partial_symtab
*
148 lookup_partial_symtab (name
)
151 register struct partial_symtab
*s
;
153 for (s
= partial_symtab_list
; s
; s
= s
->next
)
154 if (!strcmp (name
, s
->filename
))
160 /* Return a typename for a struct/union/enum type
161 without the tag qualifier. If the type has a NULL name,
164 type_name_no_tag (type
)
165 register struct type
*type
;
167 register char *name
= TYPE_NAME (type
);
173 switch (TYPE_CODE (type
))
175 case TYPE_CODE_STRUCT
:
177 case TYPE_CODE_UNION
:
184 name
= strchr (name
, ' ');
188 return TYPE_NAME (type
);
191 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
193 If this is a stubbed struct (i.e. declared as struct foo *), see if
194 we can find a full definition in some other file. If so, copy this
195 definition, so we can use it in future. If not, set a flag so we
196 don't waste too much time in future. (FIXME, this doesn't seem
199 This used to be coded as a macro, but I don't think it is called
200 often enough to merit such treatment.
203 struct complaint stub_noname_complaint
=
204 {"stub type has NULL name", 0, 0};
207 check_stub_type(type
)
210 if (TYPE_FLAGS(type
) & TYPE_FLAG_STUB
)
212 char* name
= type_name_no_tag (type
);
216 complain (&stub_noname_complaint
, 0);
219 sym
= lookup_symbol (name
, 0, STRUCT_NAMESPACE
, 0,
220 (struct symtab
**)NULL
);
222 bcopy (SYMBOL_TYPE(sym
), type
, sizeof (struct type
));
226 /* Demangle a GDB method stub type. */
228 gdb_mangle_name (type
, i
, j
)
232 int mangled_name_len
;
234 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
235 struct fn_field
*method
= &f
[j
];
236 char *field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
238 /* Need a new type prefix. */
240 char *const_prefix
= method
->is_const
? "C" : "";
241 char *volatile_prefix
= method
->is_volatile
? "V" : "";
242 char *newname
= type_name_no_tag (type
);
244 int len
= strlen (newname
);
246 sprintf (buf
, "__%s%s%d", const_prefix
, volatile_prefix
, len
);
247 mangled_name_len
= (strlen (field_name
)
249 + strlen (TYPE_FN_FIELD_PHYSNAME (f
, j
))
252 if (OPNAME_PREFIX_P (field_name
))
254 char *opname
= cplus_mangle_opname (field_name
+ 3);
256 error ("No mangling for \"%s\"", field_name
);
257 mangled_name_len
+= strlen (opname
);
258 mangled_name
= (char *)xmalloc (mangled_name_len
);
260 strncpy (mangled_name
, field_name
, 3);
261 mangled_name
[3] = '\0';
262 strcat (mangled_name
, opname
);
266 mangled_name
= (char *)xmalloc (mangled_name_len
);
267 strcpy (mangled_name
, TYPE_FN_FIELDLIST_NAME (type
, i
));
269 strcat (mangled_name
, buf
);
270 strcat (mangled_name
, newname
);
271 strcat (mangled_name
, TYPE_FN_FIELD_PHYSNAME (f
, j
));
276 /* Lookup a primitive type named NAME.
277 Return zero if NAME is not a primitive type.*/
280 lookup_primitive_typename (name
)
283 struct type
** const *p
;
285 for (p
= current_language
->la_builtin_type_vector
; *p
; p
++)
286 if(!strcmp((**p
)->name
, name
))
291 /* Lookup a typedef or primitive type named NAME,
292 visible in lexical block BLOCK.
293 If NOERR is nonzero, return zero if NAME is not suitably defined. */
296 lookup_typename (name
, block
, noerr
)
301 register struct symbol
*sym
=
302 lookup_symbol (name
, block
, VAR_NAMESPACE
, 0, (struct symtab
**)NULL
);
303 if (sym
== 0 || SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
306 tmp
= lookup_primitive_typename (name
);
309 else if (!tmp
&& noerr
)
312 error ("No type named %s.", name
);
314 return SYMBOL_TYPE (sym
);
318 lookup_unsigned_typename (name
)
321 char *uns
= alloca (strlen(name
) + 10);
323 strcpy (uns
, "unsigned ");
324 strcpy (uns
+9, name
);
325 return lookup_typename (uns
, (struct block
*)0, 0);
328 /* Lookup a structure type named "struct NAME",
329 visible in lexical block BLOCK. */
332 lookup_struct (name
, block
)
336 register struct symbol
*sym
337 = lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0, (struct symtab
**)NULL
);
340 error ("No struct type named %s.", name
);
341 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
342 error ("This context has class, union or enum %s, not a struct.", name
);
343 return SYMBOL_TYPE (sym
);
346 /* Lookup a union type named "union NAME",
347 visible in lexical block BLOCK. */
350 lookup_union (name
, block
)
354 register struct symbol
*sym
355 = lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0, (struct symtab
**)NULL
);
358 error ("No union type named %s.", name
);
359 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_UNION
)
360 error ("This context has class, struct or enum %s, not a union.", name
);
361 return SYMBOL_TYPE (sym
);
364 /* Lookup an enum type named "enum NAME",
365 visible in lexical block BLOCK. */
368 lookup_enum (name
, block
)
372 register struct symbol
*sym
373 = lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0, (struct symtab
**)NULL
);
375 error ("No enum type named %s.", name
);
376 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_ENUM
)
377 error ("This context has class, struct or union %s, not an enum.", name
);
378 return SYMBOL_TYPE (sym
);
381 /* Given a type TYPE, lookup the type of the component of type named
383 If NOERR is nonzero, return zero if NAME is not suitably defined. */
386 lookup_struct_elt_type (type
, name
, noerr
)
393 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
394 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
396 target_terminal_ours ();
398 fprintf (stderr
, "Type ");
399 type_print (type
, "", stderr
, -1);
400 error (" is not a structure or union type.");
403 check_stub_type (type
);
405 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
407 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
409 if (t_field_name
&& !strcmp (t_field_name
, name
))
410 return TYPE_FIELD_TYPE (type
, i
);
412 /* OK, it's not in this class. Recursively check the baseclasses. */
413 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
415 struct type
*t
= lookup_struct_elt_type (TYPE_BASECLASS (type
, i
),
424 target_terminal_ours ();
426 fprintf (stderr
, "Type ");
427 type_print (type
, "", stderr
, -1);
428 fprintf (stderr
, " has no component named ");
429 fputs_filtered (name
, stderr
);
431 return (struct type
*)-1; /* For lint */
434 /* Given a type TYPE, return a type of pointers to that type.
435 May need to construct such a type if this is the first use.
437 C++: use TYPE_MAIN_VARIANT and TYPE_CHAIN to keep pointer
438 to member types under control. */
441 lookup_pointer_type (type
)
444 register struct type
*ptype
= TYPE_POINTER_TYPE (type
);
445 if (ptype
) return TYPE_MAIN_VARIANT (ptype
);
447 /* This is the first time anyone wanted a pointer to a TYPE. */
448 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
449 ptype
= (struct type
*) xmalloc (sizeof (struct type
));
451 ptype
= (struct type
*) obstack_alloc (symbol_obstack
,
452 sizeof (struct type
));
454 bzero (ptype
, sizeof (struct type
));
455 TYPE_MAIN_VARIANT (ptype
) = ptype
;
456 TYPE_TARGET_TYPE (ptype
) = type
;
457 TYPE_POINTER_TYPE (type
) = ptype
;
458 /* New type is permanent if type pointed to is permanent. */
459 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
460 TYPE_FLAGS (ptype
) |= TYPE_FLAG_PERM
;
461 /* We assume the machine has only one representation for pointers! */
462 /* FIXME: This confuses host<->target data representations, and is a
463 poor assumption besides. */
464 TYPE_LENGTH (ptype
) = sizeof (char *);
465 TYPE_CODE (ptype
) = TYPE_CODE_PTR
;
470 lookup_reference_type (type
)
473 register struct type
*rtype
= TYPE_REFERENCE_TYPE (type
);
474 if (rtype
) return TYPE_MAIN_VARIANT (rtype
);
476 /* This is the first time anyone wanted a pointer to a TYPE. */
477 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
478 rtype
= (struct type
*) xmalloc (sizeof (struct type
));
480 rtype
= (struct type
*) obstack_alloc (symbol_obstack
,
481 sizeof (struct type
));
483 bzero (rtype
, sizeof (struct type
));
484 TYPE_MAIN_VARIANT (rtype
) = rtype
;
485 TYPE_TARGET_TYPE (rtype
) = type
;
486 TYPE_REFERENCE_TYPE (type
) = rtype
;
487 /* New type is permanent if type pointed to is permanent. */
488 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
489 TYPE_FLAGS (rtype
) |= TYPE_FLAG_PERM
;
490 /* We assume the machine has only one representation for pointers! */
491 TYPE_LENGTH (rtype
) = sizeof (char *);
492 TYPE_CODE (rtype
) = TYPE_CODE_REF
;
497 /* Implement direct support for MEMBER_TYPE in GNU C++.
498 May need to construct such a type if this is the first use.
499 The TYPE is the type of the member. The DOMAIN is the type
500 of the aggregate that the member belongs to. */
503 lookup_member_type (type
, domain
)
504 struct type
*type
, *domain
;
506 register struct type
*mtype
= TYPE_MAIN_VARIANT (type
);
507 struct type
*main_type
;
512 if (TYPE_DOMAIN_TYPE (mtype
) == domain
)
514 mtype
= TYPE_NEXT_VARIANT (mtype
);
517 /* This is the first time anyone wanted this member type. */
518 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
519 mtype
= (struct type
*) xmalloc (sizeof (struct type
));
521 mtype
= (struct type
*) obstack_alloc (symbol_obstack
,
522 sizeof (struct type
));
524 bzero (mtype
, sizeof (struct type
));
529 TYPE_NEXT_VARIANT (mtype
) = TYPE_NEXT_VARIANT (main_type
);
530 TYPE_NEXT_VARIANT (main_type
) = mtype
;
532 TYPE_MAIN_VARIANT (mtype
) = main_type
;
533 TYPE_TARGET_TYPE (mtype
) = type
;
534 TYPE_DOMAIN_TYPE (mtype
) = domain
;
535 /* New type is permanent if type pointed to is permanent. */
536 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
537 TYPE_FLAGS (mtype
) |= TYPE_FLAG_PERM
;
539 /* In practice, this is never used. */
540 TYPE_LENGTH (mtype
) = 1;
541 TYPE_CODE (mtype
) = TYPE_CODE_MEMBER
;
544 /* Now splice in the new member pointer type. */
547 /* This type was not "smashed". */
548 TYPE_CHAIN (mtype
) = TYPE_CHAIN (main_type
);
549 TYPE_CHAIN (main_type
) = mtype
;
556 /* Allocate a stub method whose return type is
557 TYPE. We will fill in arguments later. This always
558 returns a fresh type. If we unify this type with
559 an existing type later, the storage allocated
560 here can be freed. */
562 allocate_stub_method (type
)
565 struct type
*mtype
= (struct type
*)xmalloc (sizeof (struct type
));
566 bzero (mtype
, sizeof (struct type
));
567 TYPE_MAIN_VARIANT (mtype
) = mtype
;
568 TYPE_TARGET_TYPE (mtype
) = type
;
569 TYPE_FLAGS (mtype
) = TYPE_FLAG_STUB
;
570 TYPE_CODE (mtype
) = TYPE_CODE_METHOD
;
571 TYPE_LENGTH (mtype
) = 1;
575 /* Lookup a method type belonging to class DOMAIN, returning type TYPE,
576 and taking a list of arguments ARGS.
577 If one is not found, allocate a new one. */
580 lookup_method_type (domain
, type
, args
)
581 struct type
*domain
, *type
, **args
;
583 register struct type
*mtype
= TYPE_MAIN_VARIANT (type
);
584 struct type
*main_type
;
589 if (TYPE_DOMAIN_TYPE (mtype
) == domain
)
591 struct type
**t1
= args
;
592 struct type
**t2
= TYPE_ARG_TYPES (mtype
);
596 for (i
= 0; t1
[i
] != 0 && t1
[i
]->code
!= TYPE_CODE_VOID
; i
++)
603 mtype
= TYPE_NEXT_VARIANT (mtype
);
606 /* This is the first time anyone wanted this member type. */
607 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
608 mtype
= (struct type
*) xmalloc (sizeof (struct type
));
610 mtype
= (struct type
*) obstack_alloc (symbol_obstack
,
611 sizeof (struct type
));
613 bzero (mtype
, sizeof (struct type
));
618 TYPE_NEXT_VARIANT (mtype
) = TYPE_NEXT_VARIANT (main_type
);
619 TYPE_NEXT_VARIANT (main_type
) = mtype
;
621 TYPE_MAIN_VARIANT (mtype
) = main_type
;
622 TYPE_TARGET_TYPE (mtype
) = type
;
623 TYPE_DOMAIN_TYPE (mtype
) = domain
;
624 TYPE_ARG_TYPES (mtype
) = args
;
625 /* New type is permanent if type pointed to is permanent. */
626 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
627 TYPE_FLAGS (mtype
) |= TYPE_FLAG_PERM
;
629 /* In practice, this is never used. */
630 TYPE_LENGTH (mtype
) = 1;
631 TYPE_CODE (mtype
) = TYPE_CODE_METHOD
;
634 /* Now splice in the new member pointer type. */
637 /* This type was not "smashed". */
638 TYPE_CHAIN (mtype
) = TYPE_CHAIN (main_type
);
639 TYPE_CHAIN (main_type
) = mtype
;
647 /* Given a type TYPE, return a type which has offset OFFSET,
648 via_virtual VIA_VIRTUAL, and via_public VIA_PUBLIC.
649 May need to construct such a type if none exists. */
651 lookup_basetype_type (type
, offset
, via_virtual
, via_public
)
654 int via_virtual
, via_public
;
656 register struct type
*btype
= TYPE_MAIN_VARIANT (type
);
657 struct type
*main_type
;
661 printf ("Internal error: type offset non-zero in lookup_basetype_type");
668 if (/* TYPE_OFFSET (btype) == offset
669 && */ TYPE_VIA_PUBLIC (btype
) == via_public
670 && TYPE_VIA_VIRTUAL (btype
) == via_virtual
)
672 btype
= TYPE_NEXT_VARIANT (btype
);
675 /* This is the first time anyone wanted this member type. */
676 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
677 btype
= (struct type
*) xmalloc (sizeof (struct type
));
679 btype
= (struct type
*) obstack_alloc (symbol_obstack
,
680 sizeof (struct type
));
685 bzero (btype
, sizeof (struct type
));
686 TYPE_MAIN_VARIANT (btype
) = main_type
;
690 bcopy (main_type
, btype
, sizeof (struct type
));
691 TYPE_NEXT_VARIANT (main_type
) = btype
;
693 /* TYPE_OFFSET (btype) = offset; */
695 TYPE_FLAGS (btype
) |= TYPE_FLAG_VIA_PUBLIC
;
697 TYPE_FLAGS (btype
) |= TYPE_FLAG_VIA_VIRTUAL
;
698 /* New type is permanent if type pointed to is permanent. */
699 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
700 TYPE_FLAGS (btype
) |= TYPE_FLAG_PERM
;
702 /* In practice, this is never used. */
703 TYPE_LENGTH (btype
) = 1;
704 TYPE_CODE (btype
) = TYPE_CODE_STRUCT
;
710 /* Given a type TYPE, return a type of functions that return that type.
711 May need to construct such a type if this is the first use. */
714 lookup_function_type (type
)
717 register struct type
*ptype
= TYPE_FUNCTION_TYPE (type
);
718 if (ptype
) return ptype
;
720 /* This is the first time anyone wanted a function returning a TYPE. */
721 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
722 ptype
= (struct type
*) xmalloc (sizeof (struct type
));
724 ptype
= (struct type
*) obstack_alloc (symbol_obstack
,
725 sizeof (struct type
));
727 bzero (ptype
, sizeof (struct type
));
728 TYPE_TARGET_TYPE (ptype
) = type
;
729 TYPE_FUNCTION_TYPE (type
) = ptype
;
730 /* New type is permanent if type returned is permanent. */
731 if (TYPE_FLAGS (type
) & TYPE_FLAG_PERM
)
732 TYPE_FLAGS (ptype
) |= TYPE_FLAG_PERM
;
733 TYPE_LENGTH (ptype
) = 1;
734 TYPE_CODE (ptype
) = TYPE_CODE_FUNC
;
735 TYPE_NFIELDS (ptype
) = 0;
739 /* Create an array type. Elements will be of type TYPE, and there will
742 Eventually this should be extended to take two more arguments which
743 specify the bounds of the array and the type of the index.
744 It should also be changed to be a "lookup" function, with the
745 appropriate data structures added to the type field.
746 Then read array type should call here. */
749 create_array_type (element_type
, number
)
750 struct type
*element_type
;
753 struct type
*result_type
= (struct type
*)
754 obstack_alloc (symbol_obstack
, sizeof (struct type
));
755 struct type
*range_type
;
757 bzero (result_type
, sizeof (struct type
));
759 TYPE_CODE (result_type
) = TYPE_CODE_ARRAY
;
760 TYPE_TARGET_TYPE (result_type
) = element_type
;
761 TYPE_LENGTH (result_type
) = number
* TYPE_LENGTH (element_type
);
762 TYPE_NFIELDS (result_type
) = 1;
763 TYPE_FIELDS (result_type
) =
764 (struct field
*) obstack_alloc (symbol_obstack
, sizeof (struct field
));
767 /* Create range type. */
768 range_type
= (struct type
*) obstack_alloc (symbol_obstack
,
769 sizeof (struct type
));
770 TYPE_CODE (range_type
) = TYPE_CODE_RANGE
;
771 TYPE_TARGET_TYPE (range_type
) = builtin_type_int
; /* FIXME */
773 /* This should never be needed. */
774 TYPE_LENGTH (range_type
) = sizeof (int);
776 TYPE_NFIELDS (range_type
) = 2;
777 TYPE_FIELDS (range_type
) =
778 (struct field
*) obstack_alloc (symbol_obstack
,
779 2 * sizeof (struct field
));
780 TYPE_FIELD_BITPOS (range_type
, 0) = 0; /* FIXME */
781 TYPE_FIELD_BITPOS (range_type
, 1) = number
-1; /* FIXME */
782 TYPE_FIELD_TYPE (range_type
, 0) = builtin_type_int
; /* FIXME */
783 TYPE_FIELD_TYPE (range_type
, 1) = builtin_type_int
; /* FIXME */
785 TYPE_FIELD_TYPE(result_type
,0)=range_type
;
786 TYPE_VPTR_FIELDNO (result_type
) = -1;
792 /* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE. */
795 smash_to_member_type (type
, domain
, to_type
)
796 struct type
*type
, *domain
, *to_type
;
798 bzero (type
, sizeof (struct type
));
799 TYPE_TARGET_TYPE (type
) = to_type
;
800 TYPE_DOMAIN_TYPE (type
) = domain
;
802 /* In practice, this is never needed. */
803 TYPE_LENGTH (type
) = 1;
804 TYPE_CODE (type
) = TYPE_CODE_MEMBER
;
806 TYPE_MAIN_VARIANT (type
) = lookup_member_type (domain
, to_type
);
809 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE. */
812 smash_to_method_type (type
, domain
, to_type
, args
)
813 struct type
*type
, *domain
, *to_type
, **args
;
815 bzero (type
, sizeof (struct type
));
816 TYPE_TARGET_TYPE (type
) = to_type
;
817 TYPE_DOMAIN_TYPE (type
) = domain
;
818 TYPE_ARG_TYPES (type
) = args
;
820 /* In practice, this is never needed. */
821 TYPE_LENGTH (type
) = 1;
822 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
824 TYPE_MAIN_VARIANT (type
) = lookup_method_type (domain
, to_type
, args
);
827 /* Find which partial symtab on the partial_symtab_list contains
828 PC. Return 0 if none. */
830 struct partial_symtab
*
832 register CORE_ADDR pc
;
834 register struct partial_symtab
*ps
;
836 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
837 if (pc
>= ps
->textlow
&& pc
< ps
->texthigh
)
843 /* Find which partial symbol within a psymtab contains PC. Return 0
844 if none. Check all psymtabs if PSYMTAB is 0. */
845 struct partial_symbol
*
846 find_pc_psymbol (psymtab
, pc
)
847 struct partial_symtab
*psymtab
;
850 struct partial_symbol
*best
, *p
;
854 psymtab
= find_pc_psymtab (pc
);
858 best_pc
= psymtab
->textlow
- 1;
860 for (p
= static_psymbols
.list
+ psymtab
->statics_offset
;
861 (p
- (static_psymbols
.list
+ psymtab
->statics_offset
)
862 < psymtab
->n_static_syms
);
864 if (SYMBOL_NAMESPACE (p
) == VAR_NAMESPACE
865 && SYMBOL_CLASS (p
) == LOC_BLOCK
866 && pc
>= SYMBOL_VALUE_ADDRESS (p
)
867 && SYMBOL_VALUE_ADDRESS (p
) > best_pc
)
869 best_pc
= SYMBOL_VALUE_ADDRESS (p
);
872 if (best_pc
== psymtab
->textlow
- 1)
878 /* Find the definition for a specified symbol name NAME
879 in namespace NAMESPACE, visible from lexical block BLOCK.
880 Returns the struct symbol pointer, or zero if no symbol is found.
881 If SYMTAB is non-NULL, store the symbol table in which the
882 symbol was found there, or NULL if not found.
883 C++: if IS_A_FIELD_OF_THIS is nonzero on entry, check to see if
884 NAME is a field of the current implied argument `this'. If so set
885 *IS_A_FIELD_OF_THIS to 1, otherwise set it to zero.
886 BLOCK_FOUND is set to the block in which NAME is found (in the case of
887 a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */
890 lookup_symbol (name
, block
, namespace, is_a_field_of_this
, symtab
)
892 register struct block
*block
;
893 enum namespace namespace;
894 int *is_a_field_of_this
;
895 struct symtab
**symtab
;
897 register struct symbol
*sym
;
898 register struct symtab
*s
;
899 register struct partial_symtab
*ps
;
900 struct blockvector
*bv
;
902 /* Search specified block and its superiors. */
906 sym
= lookup_block_symbol (block
, name
, namespace);
912 /* Search the list of symtabs for one which contains the
913 address of the start of this block. */
915 for (s
= symtab_list
; s
; s
= s
->next
)
917 bv
= BLOCKVECTOR (s
);
918 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
919 if (BLOCK_START (b
) <= BLOCK_START (block
)
920 && BLOCK_END (b
) > BLOCK_START (block
))
928 block
= BLOCK_SUPERBLOCK (block
);
931 /* But that doesn't do any demangling for the STATIC_BLOCK.
932 I'm not sure whether demangling is needed in the case of
933 nested function in inner blocks; if so this needs to be changed.
935 Don't need to mess with the psymtabs; if we have a block,
936 that file is read in. If we don't, then we deal later with
937 all the psymtab stuff that needs checking. */
938 if (namespace == VAR_NAMESPACE
&& block
!= NULL
)
941 /* Find the right symtab. */
942 for (s
= symtab_list
; s
; s
= s
->next
)
944 bv
= BLOCKVECTOR (s
);
945 b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
946 if (BLOCK_START (b
) <= BLOCK_START (block
)
947 && BLOCK_END (b
) > BLOCK_START (block
))
949 sym
= lookup_demangled_block_symbol (b
, name
);
962 /* C++: If requested to do so by the caller,
963 check to see if NAME is a field of `this'. */
964 if (is_a_field_of_this
)
966 struct value
*v
= value_of_this (0);
968 *is_a_field_of_this
= 0;
969 if (v
&& check_field (v
, name
))
971 *is_a_field_of_this
= 1;
978 /* Now search all global blocks. Do the symtab's first, then
979 check the psymtab's */
981 for (s
= symtab_list
; s
; s
= s
->next
)
983 bv
= BLOCKVECTOR (s
);
984 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
985 sym
= lookup_block_symbol (block
, name
, namespace);
995 /* Check for the possibility of the symbol being a global function
996 that is stored on the misc function vector. Eventually, all
997 global symbols might be resolved in this way. */
999 if (namespace == VAR_NAMESPACE
)
1001 int ind
= lookup_misc_func (name
);
1003 /* Look for a mangled C++ name for NAME. */
1006 int name_len
= strlen (name
);
1008 for (ind
= misc_function_count
; --ind
>= 0; )
1009 /* Assume orginal name is prefix of mangled name. */
1010 if (!strncmp (misc_function_vector
[ind
].name
, name
, name_len
))
1013 cplus_demangle(misc_function_vector
[ind
].name
, -1);
1014 if (demangled
!= NULL
)
1016 int cond
= strcmp (demangled
, name
);
1022 /* Loop terminates on no match with ind == -1. */
1027 s
= find_pc_symtab (misc_function_vector
[ind
].address
);
1028 /* If S is zero, there are no debug symbols for this file.
1029 Skip this stuff and check for matching static symbols below. */
1032 bv
= BLOCKVECTOR (s
);
1033 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1034 sym
= lookup_block_symbol (block
, misc_function_vector
[ind
].name
,
1036 /* sym == 0 if symbol was found in the misc_function_vector
1037 but not in the symtab.
1038 Return 0 to use the misc_function definition of "foo_".
1040 This happens for Fortran "foo_" symbols,
1041 which are "foo" in the symtab.
1043 This can also happen if "asm" is used to make a
1044 regular symbol but not a debugging symbol, e.g.
1045 asm(".globl _main");
1056 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
1057 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 1, namespace))
1059 s
= PSYMTAB_TO_SYMTAB(ps
);
1060 bv
= BLOCKVECTOR (s
);
1061 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1062 sym
= lookup_block_symbol (block
, name
, namespace);
1064 error ("Internal: global symbol `%s' found in psymtab but not in symtab", name
);
1070 /* Now search all per-file blocks.
1071 Not strictly correct, but more useful than an error.
1072 Do the symtabs first, then check the psymtabs */
1074 for (s
= symtab_list
; s
; s
= s
->next
)
1076 bv
= BLOCKVECTOR (s
);
1077 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1078 sym
= lookup_block_symbol (block
, name
, namespace);
1081 block_found
= block
;
1088 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
1089 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 0, namespace))
1091 s
= PSYMTAB_TO_SYMTAB(ps
);
1092 bv
= BLOCKVECTOR (s
);
1093 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1094 sym
= lookup_block_symbol (block
, name
, namespace);
1096 error ("Internal: static symbol `%s' found in psymtab but not in symtab", name
);
1102 /* Now search all per-file blocks for static mangled symbols.
1103 Do the symtabs first, then check the psymtabs. */
1105 if (namespace == VAR_NAMESPACE
)
1107 for (s
= symtab_list
; s
; s
= s
->next
)
1109 bv
= BLOCKVECTOR (s
);
1110 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1111 sym
= lookup_demangled_block_symbol (block
, name
);
1114 block_found
= block
;
1121 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
1122 if (!ps
->readin
&& lookup_demangled_partial_symbol (ps
, name
))
1124 s
= PSYMTAB_TO_SYMTAB(ps
);
1125 bv
= BLOCKVECTOR (s
);
1126 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1127 sym
= lookup_demangled_block_symbol (block
, name
);
1129 error ("Internal: mangled static symbol `%s' found in psymtab but not in symtab", name
);
1141 /* Look for a static demangled symbol in block BLOCK. */
1143 static struct symbol
*
1144 lookup_demangled_block_symbol (block
, name
)
1145 register struct block
*block
;
1148 register int bot
, top
, inc
;
1149 register struct symbol
*sym
;
1152 top
= BLOCK_NSYMS (block
);
1157 sym
= BLOCK_SYM (block
, bot
);
1158 if (SYMBOL_NAME (sym
)[0] == inc
1159 && SYMBOL_NAMESPACE (sym
) == VAR_NAMESPACE
)
1161 char *demangled
= cplus_demangle(SYMBOL_NAME (sym
), -1);
1162 if (demangled
!= NULL
)
1164 int cond
= strcmp (demangled
, name
);
1176 /* Look, in partial_symtab PST, for static mangled symbol NAME. */
1178 static struct partial_symbol
*
1179 lookup_demangled_partial_symbol (pst
, name
)
1180 struct partial_symtab
*pst
;
1183 struct partial_symbol
*start
, *psym
;
1184 int length
= pst
->n_static_syms
;
1185 register int inc
= name
[0];
1188 return (struct partial_symbol
*) 0;
1190 start
= static_psymbols
.list
+ pst
->statics_offset
;
1191 for (psym
= start
; psym
< start
+ length
; psym
++)
1193 if (SYMBOL_NAME (psym
)[0] == inc
1194 && SYMBOL_NAMESPACE (psym
) == VAR_NAMESPACE
)
1196 char *demangled
= cplus_demangle(SYMBOL_NAME (psym
), -1);
1197 if (demangled
!= NULL
)
1199 int cond
= strcmp (demangled
, name
);
1207 return (struct partial_symbol
*) 0;
1210 /* Look, in partial_symtab PST, for symbol NAME. Check the global
1211 symbols if GLOBAL, the static symbols if not */
1213 static struct partial_symbol
*
1214 lookup_partial_symbol (pst
, name
, global
, namespace)
1215 struct partial_symtab
*pst
;
1218 enum namespace namespace;
1220 struct partial_symbol
*start
, *psym
;
1221 int length
= (global
? pst
->n_global_syms
: pst
->n_static_syms
);
1224 return (struct partial_symbol
*) 0;
1227 global_psymbols
.list
+ pst
->globals_offset
:
1228 static_psymbols
.list
+ pst
->statics_offset
);
1230 if (global
) /* This means we can use a binary */
1233 struct partial_symbol
*top
, *bottom
, *center
;
1235 /* Binary search. This search is guaranteed to end with center
1236 pointing at the earliest partial symbol with the correct
1237 name. At that point *all* partial symbols with that name
1238 will be checked against the correct namespace. */
1240 top
= start
+ length
- 1;
1241 while (top
> bottom
)
1243 center
= bottom
+ (top
- bottom
) / 2;
1245 assert (center
< top
);
1247 if (strcmp (SYMBOL_NAME (center
), name
) >= 0)
1250 bottom
= center
+ 1;
1252 assert (top
== bottom
);
1254 while (!strcmp (SYMBOL_NAME (top
), name
))
1256 if (SYMBOL_NAMESPACE (top
) == namespace)
1263 /* Can't use a binary search */
1264 for (psym
= start
; psym
< start
+ length
; psym
++)
1265 if (namespace == SYMBOL_NAMESPACE (psym
)
1266 && !strcmp (name
, SYMBOL_NAME (psym
)))
1270 return (struct partial_symbol
*) 0;
1273 /* Find the psymtab containing main(). */
1275 struct partial_symtab
*
1276 find_main_psymtab ()
1278 register struct partial_symtab
*pst
;
1279 for (pst
= partial_symtab_list
; pst
; pst
= pst
->next
)
1280 if (lookup_partial_symbol (pst
, "main", 1, VAR_NAMESPACE
))
1285 /* Look for a symbol in block BLOCK. */
1288 lookup_block_symbol (block
, name
, namespace)
1289 register struct block
*block
;
1291 enum namespace namespace;
1293 register int bot
, top
, inc
;
1294 register struct symbol
*sym
, *parameter_sym
;
1296 top
= BLOCK_NSYMS (block
);
1299 /* If the blocks's symbols were sorted, start with a binary search. */
1301 if (BLOCK_SHOULD_SORT (block
))
1303 /* First, advance BOT to not far before
1304 the first symbol whose name is NAME. */
1308 inc
= (top
- bot
+ 1);
1309 /* No need to keep binary searching for the last few bits worth. */
1312 inc
= (inc
>> 1) + bot
;
1313 sym
= BLOCK_SYM (block
, inc
);
1314 if (SYMBOL_NAME (sym
)[0] < name
[0])
1316 else if (SYMBOL_NAME (sym
)[0] > name
[0])
1318 else if (strcmp (SYMBOL_NAME (sym
), name
) < 0)
1324 /* Now scan forward until we run out of symbols,
1325 find one whose name is greater than NAME,
1326 or find one we want.
1327 If there is more than one symbol with the right name and namespace,
1328 we return the first one. dbxread.c is careful to make sure
1329 that if one is a register then it comes first. */
1331 top
= BLOCK_NSYMS (block
);
1334 sym
= BLOCK_SYM (block
, bot
);
1335 inc
= SYMBOL_NAME (sym
)[0] - name
[0];
1337 inc
= strcmp (SYMBOL_NAME (sym
), name
);
1338 if (inc
== 0 && SYMBOL_NAMESPACE (sym
) == namespace)
1347 /* Here if block isn't sorted.
1348 This loop is equivalent to the loop above,
1349 but hacked greatly for speed.
1351 Note that parameter symbols do not always show up last in the
1352 list; this loop makes sure to take anything else other than
1353 parameter symbols first; it only uses parameter symbols as a
1354 last resort. Note that this only takes up extra computation
1357 parameter_sym
= (struct symbol
*) 0;
1358 top
= BLOCK_NSYMS (block
);
1362 sym
= BLOCK_SYM (block
, bot
);
1363 if (SYMBOL_NAME (sym
)[0] == inc
1364 && !strcmp (SYMBOL_NAME (sym
), name
)
1365 && SYMBOL_NAMESPACE (sym
) == namespace)
1367 if (SYMBOL_CLASS (sym
) == LOC_ARG
1368 || SYMBOL_CLASS (sym
) == LOC_LOCAL_ARG
1369 || SYMBOL_CLASS (sym
) == LOC_REF_ARG
1370 || SYMBOL_CLASS (sym
) == LOC_REGPARM
)
1371 parameter_sym
= sym
;
1377 return parameter_sym
; /* Will be 0 if not found. */
1380 /* Return the symbol for the function which contains a specified
1381 lexical block, described by a struct block BL. */
1387 while (BLOCK_FUNCTION (bl
) == 0 && BLOCK_SUPERBLOCK (bl
) != 0)
1388 bl
= BLOCK_SUPERBLOCK (bl
);
1390 return BLOCK_FUNCTION (bl
);
1393 /* Subroutine of find_pc_line */
1397 register CORE_ADDR pc
;
1399 register struct block
*b
;
1400 struct blockvector
*bv
;
1401 register struct symtab
*s
;
1402 register struct partial_symtab
*ps
;
1404 /* Search all symtabs for one whose file contains our pc */
1406 for (s
= symtab_list
; s
; s
= s
->next
)
1408 bv
= BLOCKVECTOR (s
);
1409 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1410 if (BLOCK_START (b
) <= pc
1411 && BLOCK_END (b
) > pc
)
1417 ps
= find_pc_psymtab (pc
);
1418 if (ps
&& ps
->readin
)
1420 "(Internal error: pc 0x%x in read in psymtab, but not in symtab.)\n", pc
);
1423 s
= PSYMTAB_TO_SYMTAB (ps
);
1429 /* Find the source file and line number for a given PC value.
1430 Return a structure containing a symtab pointer, a line number,
1431 and a pc range for the entire source line.
1432 The value's .pc field is NOT the specified pc.
1433 NOTCURRENT nonzero means, if specified pc is on a line boundary,
1434 use the line that ends there. Otherwise, in that case, the line
1435 that begins there is used. */
1437 struct symtab_and_line
1438 find_pc_line (pc
, notcurrent
)
1443 register struct linetable
*l
;
1446 register struct linetable_entry
*item
;
1447 struct symtab_and_line val
;
1448 struct blockvector
*bv
;
1450 /* Info on best line seen so far, and where it starts, and its file. */
1453 CORE_ADDR best_pc
= 0;
1454 CORE_ADDR best_end
= 0;
1455 struct symtab
*best_symtab
= 0;
1457 /* Store here the first line number
1458 of a file which contains the line at the smallest pc after PC.
1459 If we don't find a line whose range contains PC,
1460 we will use a line one less than this,
1461 with a range from the start of that file to the first line's pc. */
1463 CORE_ADDR alt_pc
= 0;
1464 struct symtab
*alt_symtab
= 0;
1466 /* Info on best line seen in this file. */
1471 /* Info on first line of this file. */
1476 /* If this pc is not from the current frame,
1477 it is the address of the end of a call instruction.
1478 Quite likely that is the start of the following statement.
1479 But what we want is the statement containing the instruction.
1480 Fudge the pc to make sure we get that. */
1482 if (notcurrent
) pc
-= 1;
1484 s
= find_pc_symtab (pc
);
1494 bv
= BLOCKVECTOR (s
);
1496 /* Look at all the symtabs that share this blockvector.
1497 They all have the same apriori range, that we found was right;
1498 but they have different line tables. */
1500 for (; s
&& BLOCKVECTOR (s
) == bv
; s
= s
->next
)
1502 /* Find the best line in this symtab. */
1509 for (i
= 0; i
< len
; i
++)
1511 item
= &(l
->item
[i
]);
1515 first_line
= item
->line
;
1516 first_pc
= item
->pc
;
1518 /* Return the last line that did not start after PC. */
1521 prev_line
= item
->line
;
1528 /* Is this file's best line closer than the best in the other files?
1529 If so, record this file, and its best line, as best so far. */
1530 if (prev_line
>= 0 && prev_pc
> best_pc
)
1533 best_line
= prev_line
;
1536 best_end
= item
->pc
;
1540 /* Is this file's first line closer than the first lines of other files?
1541 If so, record this file, and its first line, as best alternate. */
1542 if (first_line
>= 0 && first_pc
> pc
1543 && (alt_pc
== 0 || first_pc
< alt_pc
))
1546 alt_line
= first_line
;
1550 if (best_symtab
== 0)
1552 val
.symtab
= alt_symtab
;
1553 val
.line
= alt_line
- 1;
1554 val
.pc
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
1559 val
.symtab
= best_symtab
;
1560 val
.line
= best_line
;
1562 val
.end
= (best_end
? best_end
1564 : BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
))));
1569 /* Find the PC value for a given source file and line number.
1570 Returns zero for invalid line number.
1571 The source file is specified with a struct symtab. */
1574 find_line_pc (symtab
, line
)
1575 struct symtab
*symtab
;
1578 register struct linetable
*l
;
1584 l
= LINETABLE (symtab
);
1585 ind
= find_line_common(l
, line
, &dummy
);
1586 return (ind
>= 0) ? l
->item
[ind
].pc
: 0;
1589 /* Find the range of pc values in a line.
1590 Store the starting pc of the line into *STARTPTR
1591 and the ending pc (start of next line) into *ENDPTR.
1592 Returns 1 to indicate success.
1593 Returns 0 if could not find the specified line. */
1596 find_line_pc_range (symtab
, thisline
, startptr
, endptr
)
1597 struct symtab
*symtab
;
1599 CORE_ADDR
*startptr
, *endptr
;
1601 register struct linetable
*l
;
1603 int exact_match
; /* did we get an exact linenumber match */
1608 l
= LINETABLE (symtab
);
1609 ind
= find_line_common (l
, thisline
, &exact_match
);
1612 *startptr
= l
->item
[ind
].pc
;
1613 /* If we have not seen an entry for the specified line,
1614 assume that means the specified line has zero bytes. */
1615 if (!exact_match
|| ind
== l
->nitems
-1)
1616 *endptr
= *startptr
;
1618 /* Perhaps the following entry is for the following line.
1619 It's worth a try. */
1620 if (ind
+1 < l
->nitems
1621 && l
->item
[ind
+1].line
== thisline
+ 1)
1622 *endptr
= l
->item
[ind
+1].pc
;
1624 *endptr
= find_line_pc (symtab
, thisline
+1);
1631 /* Given a line table and a line number, return the index into the line
1632 table for the pc of the nearest line whose number is >= the specified one.
1633 Return -1 if none is found. The value is >= 0 if it is an index.
1635 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
1638 find_line_common (l
, lineno
, exact_match
)
1639 register struct linetable
*l
;
1640 register int lineno
;
1646 /* BEST is the smallest linenumber > LINENO so far seen,
1647 or 0 if none has been seen so far.
1648 BEST_INDEX identifies the item for it. */
1650 int best_index
= -1;
1659 for (i
= 0; i
< len
; i
++)
1661 register struct linetable_entry
*item
= &(l
->item
[i
]);
1663 if (item
->line
== lineno
)
1669 if (item
->line
> lineno
&& (best
== 0 || item
->line
< best
))
1676 /* If we got here, we didn't get an exact match. */
1683 find_pc_line_pc_range (pc
, startptr
, endptr
)
1685 CORE_ADDR
*startptr
, *endptr
;
1687 struct symtab_and_line sal
;
1688 sal
= find_pc_line (pc
, 0);
1691 return sal
.symtab
!= 0;
1694 /* If P is of the form "operator[ \t]+..." where `...' is
1695 some legitimate operator text, return a pointer to the
1696 beginning of the substring of the operator text.
1697 Otherwise, return "". */
1699 operator_chars (p
, end
)
1704 if (strncmp (p
, "operator", 8))
1708 /* Don't get faked out by `operator' being part of a longer
1710 if ((*p
>= 'A' && *p
<= 'Z') || (*p
>= 'a' && *p
<= 'z')
1711 || *p
== '_' || *p
== '$' || *p
== '\0')
1714 /* Allow some whitespace between `operator' and the operator symbol. */
1715 while (*p
== ' ' || *p
== '\t')
1737 if (p
[1] == '=' || p
[1] == p
[0])
1748 error ("`operator ()' must be specified without whitespace in `()'");
1753 error ("`operator ?:' must be specified without whitespace in `?:'");
1758 error ("`operator []' must be specified without whitespace in `[]'");
1762 error ("`operator %s' not supported", p
);
1769 /* Recursive helper function for decode_line_1.
1770 * Look for methods named NAME in type T.
1771 * Return number of matches.
1772 * Put matches in PHYSNAMES and SYM_ARR (which better be big enough!).
1773 * These allocations seem to define "big enough":
1774 * sym_arr = (struct symbol **) alloca(TYPE_NFN_FIELDS_TOTAL (t) * sizeof(struct symbol*));
1775 * physnames = (char **) alloca (TYPE_NFN_FIELDS_TOTAL (t) * sizeof(char*));
1779 find_methods(t
, name
, physnames
, sym_arr
)
1783 struct symbol
**sym_arr
;
1787 struct symbol
*sym_class
;
1788 char *class_name
= type_name_no_tag (t
);
1789 /* Ignore this class if it doesn't have a name.
1790 This prevents core dumps, but is just a workaround
1791 because we might not find the function in
1792 certain cases, such as
1793 struct D {virtual int f();}
1794 struct C : D {virtual int g();}
1795 (in this case g++ 1.35.1- does not put out a name
1796 for D as such, it defines type 19 (for example) in
1797 the same stab as C, and then does a
1798 .stabs "D:T19" and a .stabs "D:t19".
1800 "break C::f" should not be looking for field f in
1802 but just for the field f in the baseclasses of C
1803 (no matter what their names).
1805 However, I don't know how to replace the code below
1806 that depends on knowing the name of D. */
1808 && (sym_class
= lookup_symbol (class_name
,
1809 (struct block
*)NULL
,
1812 (struct symtab
**)NULL
)))
1815 t
= SYMBOL_TYPE (sym_class
);
1816 for (method_counter
= TYPE_NFN_FIELDS (t
) - 1;
1817 method_counter
>= 0;
1821 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, method_counter
);
1823 char *method_name
= TYPE_FN_FIELDLIST_NAME (t
, method_counter
);
1824 if (!strcmp (name
, method_name
))
1825 /* Find all the fields with that name. */
1826 for (field_counter
= TYPE_FN_FIELDLIST_LENGTH (t
, method_counter
) - 1;
1831 if (TYPE_FLAGS (TYPE_FN_FIELD_TYPE (f
, field_counter
)) & TYPE_FLAG_STUB
)
1832 check_stub_method (t
, method_counter
, field_counter
);
1833 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, field_counter
);
1834 physnames
[i1
] = (char*) alloca (strlen (phys_name
) + 1);
1835 strcpy (physnames
[i1
], phys_name
);
1836 sym_arr
[i1
] = lookup_symbol (phys_name
,
1837 SYMBOL_BLOCK_VALUE (sym_class
),
1840 (struct symtab
**) NULL
);
1841 if (sym_arr
[i1
]) i1
++;
1845 /* Only search baseclasses if there is no match yet,
1846 * since names in derived classes override those in baseclasses.
1850 for (ibase
= 0; ibase
< TYPE_N_BASECLASSES (t
); ibase
++)
1851 i1
+= find_methods(TYPE_BASECLASS(t
, ibase
), name
,
1852 physnames
+ i1
, sym_arr
+ i1
);
1856 /* Parse a string that specifies a line number.
1857 Pass the address of a char * variable; that variable will be
1858 advanced over the characters actually parsed.
1862 LINENUM -- that line number in current file. PC returned is 0.
1863 FILE:LINENUM -- that line in that file. PC returned is 0.
1864 FUNCTION -- line number of openbrace of that function.
1865 PC returned is the start of the function.
1866 VARIABLE -- line number of definition of that variable.
1868 FILE:FUNCTION -- likewise, but prefer functions in that file.
1869 *EXPR -- line in which address EXPR appears.
1871 FUNCTION may be an undebuggable function found in misc_function_vector.
1873 If the argument FUNFIRSTLINE is nonzero, we want the first line
1874 of real code inside a function when a function is specified.
1876 DEFAULT_SYMTAB specifies the file to use if none is specified.
1877 It defaults to current_source_symtab.
1878 DEFAULT_LINE specifies the line number to use for relative
1879 line numbers (that start with signs). Defaults to current_source_line.
1881 Note that it is possible to return zero for the symtab
1882 if no file is validly specified. Callers must check that.
1883 Also, the line number returned may be invalid. */
1885 struct symtabs_and_lines
1886 decode_line_1 (argptr
, funfirstline
, default_symtab
, default_line
)
1889 struct symtab
*default_symtab
;
1892 struct symtabs_and_lines
decode_line_2 ();
1893 struct symtabs_and_lines values
;
1894 struct symtab_and_line val
;
1895 register char *p
, *p1
;
1897 register struct symtab
*s
;
1899 register struct symbol
*sym
;
1900 /* The symtab that SYM was found in. */
1901 struct symtab
*sym_symtab
;
1903 register CORE_ADDR pc
;
1906 struct symbol
*sym_class
;
1908 struct symbol
**sym_arr
;
1912 /* Defaults have defaults. */
1914 if (default_symtab
== 0)
1916 default_symtab
= current_source_symtab
;
1917 default_line
= current_source_line
;
1920 /* See if arg is *PC */
1922 if (**argptr
== '*')
1925 pc
= parse_and_eval_address_1 (argptr
);
1926 values
.sals
= (struct symtab_and_line
*)
1927 xmalloc (sizeof (struct symtab_and_line
));
1929 values
.sals
[0] = find_pc_line (pc
, 0);
1930 values
.sals
[0].pc
= pc
;
1934 /* Maybe arg is FILE : LINENUM or FILE : FUNCTION */
1938 for (p
= *argptr
; *p
; p
++)
1940 if (p
[0] == ':' || p
[0] == ' ' || p
[0] == '\t')
1943 while (p
[0] == ' ' || p
[0] == '\t') p
++;
1951 /* Extract the class name. */
1953 while (p
!= *argptr
&& p
[-1] == ' ') --p
;
1954 copy
= (char *) alloca (p
- *argptr
+ 1);
1955 bcopy (*argptr
, copy
, p
- *argptr
);
1956 copy
[p
- *argptr
] = 0;
1958 /* Discard the class name from the arg. */
1960 while (*p
== ' ' || *p
== '\t') p
++;
1963 sym_class
= lookup_symbol (copy
, 0, STRUCT_NAMESPACE
, 0,
1964 (struct symtab
**)NULL
);
1967 (TYPE_CODE (SYMBOL_TYPE (sym_class
)) == TYPE_CODE_STRUCT
1968 || TYPE_CODE (SYMBOL_TYPE (sym_class
)) == TYPE_CODE_UNION
))
1970 /* Arg token is not digits => try it as a function name
1971 Find the next token (everything up to end or next whitespace). */
1973 while (*p
&& *p
!= ' ' && *p
!= '\t' && *p
!= ',' && *p
!=':') p
++;
1974 q
= operator_chars (*argptr
, &q1
);
1976 copy
= (char *) alloca (p
- *argptr
+ 1 + (q1
- q
));
1981 copy
[2] = CPLUS_MARKER
;
1982 bcopy (q
, copy
+ 3, q1
- q
);
1983 copy
[3 + (q1
- q
)] = '\0';
1988 bcopy (*argptr
, copy
, p
- *argptr
);
1989 copy
[p
- *argptr
] = '\0';
1992 /* no line number may be specified */
1993 while (*p
== ' ' || *p
== '\t') p
++;
1997 i1
= 0; /* counter for the symbol array */
1998 t
= SYMBOL_TYPE (sym_class
);
1999 sym_arr
= (struct symbol
**) alloca(TYPE_NFN_FIELDS_TOTAL (t
) * sizeof(struct symbol
*));
2000 physnames
= (char **) alloca (TYPE_NFN_FIELDS_TOTAL (t
) * sizeof(char*));
2002 if (destructor_name_p (copy
, t
))
2004 /* destructors are a special case. */
2005 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, 0);
2006 int len
= TYPE_FN_FIELDLIST_LENGTH (t
, 0) - 1;
2007 char *phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, len
);
2008 physnames
[i1
] = (char *)alloca (strlen (phys_name
) + 1);
2009 strcpy (physnames
[i1
], phys_name
);
2011 lookup_symbol (phys_name
, SYMBOL_BLOCK_VALUE (sym_class
),
2012 VAR_NAMESPACE
, 0, (struct symtab
**)NULL
);
2013 if (sym_arr
[i1
]) i1
++;
2016 i1
= find_methods (t
, copy
, physnames
, sym_arr
);
2019 /* There is exactly one field with that name. */
2022 if (sym
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2024 /* Arg is the name of a function */
2025 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) + FUNCTION_START_OFFSET
;
2028 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
2030 values
.sals
[0] = find_pc_line (pc
, 0);
2031 values
.sals
[0].pc
= (values
.sals
[0].end
&& values
.sals
[0].pc
!= pc
) ? values
.sals
[0].end
: pc
;
2041 /* There is more than one field with that name
2042 (overloaded). Ask the user which one to use. */
2043 return decode_line_2 (sym_arr
, i1
, funfirstline
);
2049 if (OPNAME_PREFIX_P (copy
))
2051 tmp
= (char *)alloca (strlen (copy
+3) + 9);
2052 strcpy (tmp
, "operator ");
2053 strcat (tmp
, copy
+3);
2058 error ("The class `%s' does not have destructor defined",
2061 error ("The class %s does not have any method named %s",
2062 sym_class
->name
, tmp
);
2066 /* The quotes are important if copy is empty. */
2067 error("No class, struct, or union named \"%s\"", copy
);
2072 /* Extract the file name. */
2074 while (p
!= *argptr
&& p
[-1] == ' ') --p
;
2075 copy
= (char *) alloca (p
- *argptr
+ 1 + (q1
- q
));
2080 copy
[2] = CPLUS_MARKER
;
2081 bcopy (q
, copy
+ 3, q1
-q
);
2082 copy
[3 + (q1
-q
)] = 0;
2087 bcopy (*argptr
, copy
, p
- *argptr
);
2088 copy
[p
- *argptr
] = 0;
2091 /* Find that file's data. */
2092 s
= lookup_symtab (copy
);
2095 if (symtab_list
== 0 && partial_symtab_list
== 0)
2096 error (no_symtab_msg
);
2097 error ("No source file named %s.", copy
);
2100 /* Discard the file name from the arg. */
2102 while (*p
== ' ' || *p
== '\t') p
++;
2106 /* S is specified file's symtab, or 0 if no file specified.
2107 arg no longer contains the file name. */
2109 /* Check whether arg is all digits (and sign) */
2112 if (*p
== '-' || *p
== '+') p
++;
2113 while (*p
>= '0' && *p
<= '9')
2116 if (p
!= *argptr
&& (*p
== 0 || *p
== ' ' || *p
== '\t' || *p
== ','))
2118 /* We found a token consisting of all digits -- at least one digit. */
2119 enum sign
{none
, plus
, minus
} sign
= none
;
2121 /* This is where we need to make sure that we have good defaults.
2122 We must guarantee that this section of code is never executed
2123 when we are called with just a function name, since
2124 select_source_symtab calls us with such an argument */
2126 if (s
== 0 && default_symtab
== 0)
2128 select_source_symtab (0);
2129 default_symtab
= current_source_symtab
;
2130 default_line
= current_source_line
;
2133 if (**argptr
== '+')
2134 sign
= plus
, (*argptr
)++;
2135 else if (**argptr
== '-')
2136 sign
= minus
, (*argptr
)++;
2137 val
.line
= atoi (*argptr
);
2144 val
.line
= default_line
+ val
.line
;
2150 val
.line
= default_line
- val
.line
;
2155 break; /* No need to adjust val.line. */
2158 while (*p
== ' ' || *p
== '\t') p
++;
2164 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
2165 values
.sals
[0] = val
;
2170 /* Arg token is not digits => try it as a variable name
2171 Find the next token (everything up to end or next whitespace). */
2173 while (*p
&& *p
!= ' ' && *p
!= '\t' && *p
!= ',') p
++;
2174 copy
= (char *) alloca (p
- *argptr
+ 1);
2175 bcopy (*argptr
, copy
, p
- *argptr
);
2176 copy
[p
- *argptr
] = 0;
2177 while (*p
== ' ' || *p
== '\t') p
++;
2180 /* Look up that token as a variable.
2181 If file specified, use that file's per-file block to start with. */
2183 sym
= lookup_symbol (copy
,
2184 (s
? BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)
2185 : get_selected_block ()),
2186 VAR_NAMESPACE
, 0, &sym_symtab
);
2190 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2192 /* Arg is the name of a function */
2193 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) + FUNCTION_START_OFFSET
;
2196 val
= find_pc_line (pc
, 0);
2197 #ifdef PROLOGUE_FIRSTLINE_OVERLAP
2198 /* Convex: no need to suppress code on first line, if any */
2201 val
.pc
= (val
.end
&& val
.pc
!= pc
) ? val
.end
: pc
;
2203 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
2204 values
.sals
[0] = val
;
2207 /* I think this is always the same as the line that
2208 we calculate above, but the general principle is
2209 "trust the symbols more than stuff like
2211 if (SYMBOL_LINE (sym
) != 0)
2212 values
.sals
[0].line
= SYMBOL_LINE (sym
);
2216 else if (SYMBOL_LINE (sym
) != 0)
2218 /* We know its line number. */
2219 values
.sals
= (struct symtab_and_line
*)
2220 xmalloc (sizeof (struct symtab_and_line
));
2222 bzero (&values
.sals
[0], sizeof (values
.sals
[0]));
2223 values
.sals
[0].symtab
= sym_symtab
;
2224 values
.sals
[0].line
= SYMBOL_LINE (sym
);
2228 /* This can happen if it is compiled with a compiler which doesn't
2229 put out line numbers for variables. */
2230 error ("Line number not known for symbol \"%s\"", copy
);
2233 if ((i
= lookup_misc_func (copy
)) >= 0)
2237 val
.pc
= misc_function_vector
[i
].address
+ FUNCTION_START_OFFSET
;
2239 SKIP_PROLOGUE (val
.pc
);
2240 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
2241 values
.sals
[0] = val
;
2246 if (symtab_list
== 0 && partial_symtab_list
== 0 && misc_function_count
== 0)
2247 error (no_symtab_msg
);
2249 error ("Function %s not defined.", copy
);
2250 return values
; /* for lint */
2253 struct symtabs_and_lines
2254 decode_line_spec (string
, funfirstline
)
2258 struct symtabs_and_lines sals
;
2260 error ("Empty line specification.");
2261 sals
= decode_line_1 (&string
, funfirstline
,
2262 current_source_symtab
, current_source_line
);
2264 error ("Junk at end of line specification: %s", string
);
2268 /* Given a list of NELTS symbols in sym_arr (with corresponding
2269 mangled names in physnames), return a list of lines to operate on
2270 (ask user if necessary). */
2271 struct symtabs_and_lines
2272 decode_line_2 (sym_arr
, nelts
, funfirstline
)
2273 struct symbol
*sym_arr
[];
2277 struct symtabs_and_lines values
, return_values
;
2278 register CORE_ADDR pc
;
2279 char *args
, *arg1
, *command_line_input ();
2283 values
.sals
= (struct symtab_and_line
*) alloca (nelts
* sizeof(struct symtab_and_line
));
2284 return_values
.sals
= (struct symtab_and_line
*) xmalloc (nelts
* sizeof(struct symtab_and_line
));
2287 printf("[0] cancel\n[1] all\n");
2290 if (sym_arr
[i
] && SYMBOL_CLASS (sym_arr
[i
]) == LOC_BLOCK
)
2292 /* Arg is the name of a function */
2293 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym_arr
[i
]))
2294 + FUNCTION_START_OFFSET
;
2297 values
.sals
[i
] = find_pc_line (pc
, 0);
2298 values
.sals
[i
].pc
= (values
.sals
[i
].end
&& values
.sals
[i
].pc
!= pc
) ?
2299 values
.sals
[i
].end
: pc
;
2300 printf("[%d] file:%s; line number:%d\n",
2301 (i
+2), values
.sals
[i
].symtab
->filename
, values
.sals
[i
].line
);
2303 else printf ("?HERE\n");
2307 if ((prompt
= getenv ("PS2")) == NULL
)
2311 printf("%s ",prompt
);
2314 args
= command_line_input (0, 0);
2317 error_no_arg ("one or more choice numbers");
2325 while (*arg1
>= '0' && *arg1
<= '9') arg1
++;
2326 if (*arg1
&& *arg1
!= ' ' && *arg1
!= '\t')
2327 error ("Arguments must be choice numbers.");
2332 error ("cancelled");
2335 bcopy (values
.sals
, return_values
.sals
, (nelts
* sizeof(struct symtab_and_line
)));
2336 return_values
.nelts
= nelts
;
2337 return return_values
;
2340 if (num
> nelts
+ 2)
2342 printf ("No choice number %d.\n", num
);
2347 if (values
.sals
[num
].pc
)
2349 return_values
.sals
[i
++] = values
.sals
[num
];
2350 values
.sals
[num
].pc
= 0;
2354 printf ("duplicate request for %d ignored.\n", num
);
2359 while (*args
== ' ' || *args
== '\t') args
++;
2361 return_values
.nelts
= i
;
2362 return return_values
;
2365 /* Return the index of misc function named NAME. */
2368 lookup_misc_func (name
)
2369 register char *name
;
2373 for (i
= 0; i
< misc_function_count
; i
++)
2374 if (!strcmp (misc_function_vector
[i
].name
, name
))
2376 return -1; /* not found */
2379 /* Slave routine for sources_info. Force line breaks at ,'s.
2380 NAME is the name to print and *FIRST is nonzero if this is the first
2381 name printed. Set *FIRST to zero. */
2383 output_source_filename (name
, first
)
2388 /* Table of files printed so far. Since a single source file can
2389 result in several partial symbol tables, we need to avoid printing
2390 it more than once. Note: if some of the psymtabs are read in and
2391 some are not, it gets printed both under "Source files for which
2392 symbols have been read" and "Source files for which symbols will
2393 be read in on demand". I consider this a reasonable way to deal
2394 with the situation. I'm not sure whether this can also happen for
2395 symtabs; it doesn't hurt to check. */
2396 static char **tab
= NULL
;
2397 /* Allocated size of tab in elements.
2398 Start with one 256-byte block (when using GNU malloc.c).
2399 24 is the malloc overhead when range checking is in effect. */
2400 static int tab_alloc_size
= (256 - 24) / sizeof (char *);
2401 /* Current size of tab in elements. */
2402 static int tab_cur_size
;
2409 tab
= (char **) xmalloc (tab_alloc_size
* sizeof (*tab
));
2413 /* Is NAME in tab? */
2414 for (p
= tab
; p
< tab
+ tab_cur_size
; p
++)
2415 if (strcmp (*p
, name
) == 0)
2416 /* Yes; don't print it again. */
2418 /* No; add it to tab. */
2419 if (tab_cur_size
== tab_alloc_size
)
2421 tab_alloc_size
*= 2;
2422 tab
= (char **) xrealloc (tab
, tab_alloc_size
* sizeof (*tab
));
2424 tab
[tab_cur_size
++] = name
;
2433 printf_filtered (",");
2437 if (column
!= 0 && column
+ strlen (name
) >= 70)
2439 printf_filtered ("\n");
2442 else if (column
!= 0)
2444 printf_filtered (" ");
2447 fputs_filtered (name
, stdout
);
2448 column
+= strlen (name
);
2454 register struct symtab
*s
;
2455 register struct partial_symtab
*ps
;
2458 if (symtab_list
== 0 && partial_symtab_list
== 0)
2460 printf (no_symtab_msg
);
2464 printf_filtered ("Source files for which symbols have been read in:\n\n");
2467 for (s
= symtab_list
; s
; s
= s
->next
)
2468 output_source_filename (s
->filename
, &first
);
2469 printf_filtered ("\n\n");
2471 printf_filtered ("Source files for which symbols will be read in on demand:\n\n");
2474 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
2476 output_source_filename (ps
->filename
, &first
);
2477 printf_filtered ("\n");
2480 /* List all symbols (if REGEXP is 0) or all symbols matching REGEXP.
2481 If CLASS is zero, list all symbols except functions and type names.
2482 If CLASS is 1, list only functions.
2483 If CLASS is 2, list only type names.
2484 If CLASS is 3, list only method names.
2486 BPT is non-zero if we should set a breakpoint at the functions
2490 list_symbols (regexp
, class, bpt
)
2495 register struct symtab
*s
;
2496 register struct partial_symtab
*ps
;
2497 register struct blockvector
*bv
;
2498 struct blockvector
*prev_bv
= 0;
2499 register struct block
*b
;
2501 register struct symbol
*sym
;
2502 struct partial_symbol
*psym
;
2504 static char *classnames
[]
2505 = {"variable", "function", "type", "method"};
2506 int found_in_file
= 0;
2508 static enum misc_function_type types
[]
2509 = {mf_data
, mf_text
, mf_abs
, mf_unknown
};
2510 static enum misc_function_type types2
[]
2511 = {mf_bss
, mf_text
, mf_abs
, mf_unknown
};
2512 enum misc_function_type ourtype
= types
[class];
2513 enum misc_function_type ourtype2
= types2
[class];
2516 if (0 != (val
= re_comp (regexp
)))
2517 error ("Invalid regexp (%s): %s", val
, regexp
);
2519 /* Search through the partial_symtab_list *first* for all symbols
2520 matching the regexp. That way we don't have to reproduce all of
2521 the machinery below. */
2522 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
2524 struct partial_symbol
*bound
, *gbound
, *sbound
;
2527 if (ps
->readin
) continue;
2529 gbound
= global_psymbols
.list
+ ps
->globals_offset
+ ps
->n_global_syms
;
2530 sbound
= static_psymbols
.list
+ ps
->statics_offset
+ ps
->n_static_syms
;
2533 /* Go through all of the symbols stored in a partial
2534 symtab in one loop. */
2535 psym
= global_psymbols
.list
+ ps
->globals_offset
;
2540 if (bound
== gbound
&& ps
->n_static_syms
!= 0)
2542 psym
= static_psymbols
.list
+ ps
->statics_offset
;
2553 /* If it would match (logic taken from loop below)
2554 load the file and go on to the next one */
2555 if ((regexp
== 0 || re_exec (SYMBOL_NAME (psym
)))
2556 && ((class == 0 && SYMBOL_CLASS (psym
) != LOC_TYPEDEF
2557 && SYMBOL_CLASS (psym
) != LOC_BLOCK
)
2558 || (class == 1 && SYMBOL_CLASS (psym
) == LOC_BLOCK
)
2559 || (class == 2 && SYMBOL_CLASS (psym
) == LOC_TYPEDEF
)
2560 || (class == 3 && SYMBOL_CLASS (psym
) == LOC_BLOCK
)))
2562 (void) PSYMTAB_TO_SYMTAB(ps
);
2570 /* Here, we search through the misc function vector for functions that
2571 match, and call find_pc_symtab on them to force their symbols to
2572 be read. The symbol will then be found during the scan of symtabs
2573 below. If find_pc_symtab fails, set found_misc so that we will
2574 rescan to print any matching symbols without debug info. */
2577 for (i
= 0; i
< misc_function_count
; i
++) {
2578 if (misc_function_vector
[i
].type
!= ourtype
2579 && misc_function_vector
[i
].type
!= ourtype2
)
2581 if (regexp
== 0 || re_exec (misc_function_vector
[i
].name
)) {
2582 if (0 == find_pc_symtab (misc_function_vector
[i
].address
))
2588 /* Printout here so as to get after the "Reading in symbols"
2589 messages which will be generated above. */
2591 printf_filtered (regexp
2592 ? "All %ss matching regular expression \"%s\":\n"
2593 : "All defined %ss:\n",
2597 for (s
= symtab_list
; s
; s
= s
->next
)
2600 bv
= BLOCKVECTOR (s
);
2601 /* Often many files share a blockvector.
2602 Scan each blockvector only once so that
2603 we don't get every symbol many times.
2604 It happens that the first symtab in the list
2605 for any given blockvector is the main file. */
2607 for (i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; i
++)
2609 b
= BLOCKVECTOR_BLOCK (bv
, i
);
2610 /* Skip the sort if this block is always sorted. */
2611 if (!BLOCK_SHOULD_SORT (b
))
2612 sort_block_syms (b
);
2613 for (j
= 0; j
< BLOCK_NSYMS (b
); j
++)
2616 sym
= BLOCK_SYM (b
, j
);
2617 if ((regexp
== 0 || re_exec (SYMBOL_NAME (sym
)))
2618 && ((class == 0 && SYMBOL_CLASS (sym
) != LOC_TYPEDEF
2619 && SYMBOL_CLASS (sym
) != LOC_BLOCK
)
2620 || (class == 1 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2621 || (class == 2 && SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
2622 || (class == 3 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)))
2626 /* Set a breakpoint here, if it's a function */
2628 break_command (SYMBOL_NAME(sym
), 0);
2630 else if (!found_in_file
)
2632 fputs_filtered ("\nFile ", stdout
);
2633 fputs_filtered (s
->filename
, stdout
);
2634 fputs_filtered (":\n", stdout
);
2638 if (class != 2 && i
== STATIC_BLOCK
)
2639 printf_filtered ("static ");
2641 /* Typedef that is not a C++ class */
2643 && SYMBOL_NAMESPACE (sym
) != STRUCT_NAMESPACE
)
2644 typedef_print (SYMBOL_TYPE(sym
), sym
, stdout
);
2645 /* variable, func, or typedef-that-is-c++-class */
2646 else if (class < 2 ||
2648 SYMBOL_NAMESPACE(sym
) == STRUCT_NAMESPACE
))
2650 type_print (SYMBOL_TYPE (sym
),
2651 (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
2652 ? "" : SYMBOL_NAME (sym
)),
2655 printf_filtered (";\n");
2661 type_print_base (TYPE_FN_FIELD_TYPE(t
, i
), stdout
, 0, 0);
2662 type_print_varspec_prefix (TYPE_FN_FIELD_TYPE(t
, i
), stdout
, 0);
2663 sprintf (buf
, " %s::", type_name_no_tag (t
));
2664 type_print_method_args (TYPE_FN_FIELD_ARGS (t
, i
), buf
, name
, stdout
);
2674 /* If there are no eyes, avoid all contact. I mean, if there are
2675 no debug symbols, then print directly from the misc_function_vector. */
2677 if (found_misc
|| class != 1) {
2679 for (i
= 0; i
< misc_function_count
; i
++) {
2680 if (misc_function_vector
[i
].type
!= ourtype
2681 && misc_function_vector
[i
].type
!= ourtype2
)
2683 if (regexp
== 0 || re_exec (misc_function_vector
[i
].name
)) {
2684 /* Functions: Look up by address. */
2686 if (0 != find_pc_symtab (misc_function_vector
[i
].address
))
2688 /* Variables/Absolutes: Look up by name */
2689 if (0 != lookup_symbol (misc_function_vector
[i
].name
,
2690 (struct block
*)0, VAR_NAMESPACE
, 0, (struct symtab
**)0))
2692 if (!found_in_file
) {
2693 printf_filtered ("\nNon-debugging symbols:\n");
2696 printf_filtered (" %08x %s\n",
2697 misc_function_vector
[i
].address
,
2698 misc_function_vector
[i
].name
);
2705 variables_info (regexp
)
2708 list_symbols (regexp
, 0, 0);
2712 functions_info (regexp
)
2715 list_symbols (regexp
, 1, 0);
2722 list_symbols (regexp
, 2, 0);
2726 /* Tiemann says: "info methods was never implemented." */
2728 methods_info (regexp
)
2731 list_symbols (regexp
, 3, 0);
2735 /* Breakpoint all functions matching regular expression. */
2737 rbreak_command (regexp
)
2740 list_symbols (regexp
, 1, 1);
2743 /* Helper function to initialize the standard scalar types. */
2746 init_type (code
, length
, uns
, name
)
2747 enum type_code code
;
2751 register struct type
*type
;
2753 type
= (struct type
*) xmalloc (sizeof (struct type
));
2754 bzero (type
, sizeof *type
);
2755 TYPE_MAIN_VARIANT (type
) = type
;
2756 TYPE_CODE (type
) = code
;
2757 TYPE_LENGTH (type
) = length
;
2758 TYPE_FLAGS (type
) = uns
? TYPE_FLAG_UNSIGNED
: 0;
2759 TYPE_FLAGS (type
) |= TYPE_FLAG_PERM
;
2760 TYPE_NFIELDS (type
) = 0;
2761 TYPE_NAME (type
) = name
;
2764 TYPE_NFN_FIELDS (type
) = 0;
2765 TYPE_N_BASECLASSES (type
) = 0;
2769 /* Return Nonzero if block a is lexically nested within block b,
2770 or if a and b have the same pc range.
2771 Return zero otherwise. */
2774 struct block
*a
, *b
;
2778 return BLOCK_START (a
) >= BLOCK_START (b
)
2779 && BLOCK_END (a
) <= BLOCK_END (b
);
2783 /* Helper routine for make_symbol_completion_list. */
2785 int return_val_size
, return_val_index
;
2789 completion_list_add_symbol (symname
)
2792 if (return_val_index
+ 3 > return_val_size
)
2794 (char **)xrealloc (return_val
,
2795 (return_val_size
*= 2) * sizeof (char *));
2797 return_val
[return_val_index
] =
2798 (char *)xmalloc (1 + strlen (symname
));
2800 strcpy (return_val
[return_val_index
], symname
);
2802 return_val
[++return_val_index
] = (char *)NULL
;
2805 /* Return a NULL terminated array of all symbols (regardless of class) which
2806 begin by matching TEXT. If the answer is no symbols, then the return value
2807 is an array which contains only a NULL pointer.
2809 Problem: All of the symbols have to be copied because readline
2810 frees them. I'm not going to worry about this; hopefully there
2811 won't be that many. */
2814 make_symbol_completion_list (text
)
2817 register struct symtab
*s
;
2818 register struct partial_symtab
*ps
;
2819 register struct block
*b
, *surrounding_static_block
= 0;
2820 extern struct block
*get_selected_block ();
2822 struct partial_symbol
*psym
;
2824 int text_len
= strlen (text
);
2825 return_val_size
= 100;
2826 return_val_index
= 0;
2828 (char **)xmalloc ((1 + return_val_size
) *sizeof (char *));
2829 return_val
[0] = (char *)NULL
;
2831 /* Look through the partial symtabs for all symbols which begin
2832 by matching TEXT. Add each one that you find to the list. */
2834 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
2836 /* If the psymtab's been read in we'll get it when we search
2837 through the blockvector. */
2838 if (ps
->readin
) continue;
2840 for (psym
= global_psymbols
.list
+ ps
->globals_offset
;
2841 psym
< (global_psymbols
.list
+ ps
->globals_offset
2842 + ps
->n_global_syms
);
2845 QUIT
; /* If interrupted, then quit. */
2846 if ((strncmp (SYMBOL_NAME (psym
), text
, text_len
) == 0))
2847 completion_list_add_symbol (SYMBOL_NAME (psym
));
2850 for (psym
= static_psymbols
.list
+ ps
->statics_offset
;
2851 psym
< (static_psymbols
.list
+ ps
->statics_offset
2852 + ps
->n_static_syms
);
2856 if ((strncmp (SYMBOL_NAME (psym
), text
, text_len
) == 0))
2857 completion_list_add_symbol (SYMBOL_NAME (psym
));
2861 /* At this point scan through the misc function vector and add each
2862 symbol you find to the list. Eventually we want to ignore
2863 anything that isn't a text symbol (everything else will be
2864 handled by the psymtab code above). */
2866 for (i
= 0; i
< misc_function_count
; i
++)
2867 if (!strncmp (text
, misc_function_vector
[i
].name
, text_len
))
2868 completion_list_add_symbol (misc_function_vector
[i
].name
);
2870 /* Search upwards from currently selected frame (so that we can
2871 complete on local vars. */
2872 for (b
= get_selected_block (); b
; b
= BLOCK_SUPERBLOCK (b
))
2874 if (!BLOCK_SUPERBLOCK (b
))
2875 surrounding_static_block
= b
; /* For elmin of dups */
2877 /* Also catch fields of types defined in this places which
2878 match our text string. Only complete on types visible
2879 from current context. */
2880 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2882 register struct symbol
*sym
= BLOCK_SYM (b
, i
);
2884 if (!strncmp (SYMBOL_NAME (sym
), text
, text_len
))
2885 completion_list_add_symbol (SYMBOL_NAME (sym
));
2887 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
2889 struct type
*t
= SYMBOL_TYPE (sym
);
2890 enum type_code c
= TYPE_CODE (t
);
2892 if (c
== TYPE_CODE_UNION
|| c
== TYPE_CODE_STRUCT
)
2893 for (j
= TYPE_N_BASECLASSES (t
); j
< TYPE_NFIELDS (t
); j
++)
2894 if (TYPE_FIELD_NAME (t
, j
) &&
2895 !strncmp (TYPE_FIELD_NAME (t
, j
), text
, text_len
))
2896 completion_list_add_symbol (TYPE_FIELD_NAME (t
, j
));
2901 /* Go through the symtabs and check the externs and statics for
2902 symbols which match. */
2904 for (s
= symtab_list
; s
; s
= s
->next
)
2906 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
2908 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2909 if (!strncmp (SYMBOL_NAME (BLOCK_SYM (b
, i
)), text
, text_len
))
2910 completion_list_add_symbol (SYMBOL_NAME (BLOCK_SYM (b
, i
)));
2913 for (s
= symtab_list
; s
; s
= s
->next
)
2915 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
2917 /* Don't do this block twice. */
2918 if (b
== surrounding_static_block
) continue;
2920 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2921 if (!strncmp (SYMBOL_NAME (BLOCK_SYM (b
, i
)), text
, text_len
))
2922 completion_list_add_symbol (SYMBOL_NAME (BLOCK_SYM (b
, i
)));
2925 return (return_val
);
2929 /* Add the type of the symbol sym to the type of the current
2930 function whose block we are in (assumed). The type of
2931 this current function is contained in *TYPE.
2933 This basically works as follows: When we find a function
2934 symbol (N_FUNC with a 'f' or 'F' in the symbol name), we record
2935 a pointer to its type in the global in_function_type. Every
2936 time we come across a parameter symbol ('p' in its name), then
2937 this procedure adds the name and type of that parameter
2938 to the function type pointed to by *TYPE. (Which should correspond
2939 to in_function_type if it was called correctly).
2941 Note that since we are modifying a type, the result of
2942 lookup_function_type() should be bcopy()ed before calling
2943 this. When not in strict typing mode, the expression
2944 evaluator can choose to ignore this.
2946 Assumption: All of a function's parameter symbols will
2947 appear before another function symbol is found. The parameters
2948 appear in the same order in the argument list as they do in the
2952 add_param_to_type (type
,sym
)
2956 int num
= ++(TYPE_NFIELDS(*type
));
2958 if(TYPE_NFIELDS(*type
)-1)
2959 TYPE_FIELDS(*type
) =
2960 (struct field
*)xrealloc((char *)(TYPE_FIELDS(*type
)),
2961 num
*sizeof(struct field
));
2963 TYPE_FIELDS(*type
) =
2964 (struct field
*)xmalloc(num
*sizeof(struct field
));
2966 TYPE_FIELD_BITPOS(*type
,num
-1) = num
-1;
2967 TYPE_FIELD_BITSIZE(*type
,num
-1) = 0;
2968 TYPE_FIELD_TYPE(*type
,num
-1) = SYMBOL_TYPE(sym
);
2969 TYPE_FIELD_NAME(*type
,num
-1) = SYMBOL_NAME(sym
);
2974 _initialize_symtab ()
2976 add_info ("variables", variables_info
,
2977 "All global and static variable names, or those matching REGEXP.");
2978 add_info ("functions", functions_info
,
2979 "All function names, or those matching REGEXP.");
2981 /* FIXME: This command has at least the following problems:
2982 1. It prints builtin types (in a very strange and confusing fashion).
2983 2. It doesn't print right, e.g. with
2984 typedef struct foo *FOO
2985 type_print prints "FOO" when we want to make it (in this situation)
2986 print "struct foo *".
2987 I also think "ptype" or "whatis" is more likely to be useful (but if
2988 there is much disagreement "info types" can be fixed). */
2989 add_info ("types", types_info
,
2990 "All types names, or those matching REGEXP.");
2993 add_info ("methods", methods_info
,
2994 "All method names, or those matching REGEXP::REGEXP.\n\
2995 If the class qualifier is ommited, it is assumed to be the current scope.\n\
2996 If the first REGEXP is ommited, then all methods matching the second REGEXP\n\
2999 add_info ("sources", sources_info
,
3000 "Source files in the program.");
3002 add_com ("rbreak", no_class
, rbreak_command
,
3003 "Set a breakpoint for all functions matching REGEXP.");
3005 /* Initialize the one built-in type that isn't language dependent... */
3006 builtin_type_error
= init_type (TYPE_CODE_ERROR
, 0, 0, "<unknown type>");