1 /* Parser for linespec for the GNU debugger, GDB.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
3 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
32 #include "completer.h"
34 #include "parser-defs.h"
36 #include "objc-lang.h"
39 /* We share this one with symtab.c, but it is not exported widely. */
41 extern char *operator_chars (char *, char **);
43 /* Prototypes for local functions */
45 static void initialize_defaults (struct symtab
**default_symtab
,
48 static void set_flags (char *arg
, int *is_quoted
, char **paren_pointer
);
50 static struct symtabs_and_lines
decode_indirect (char **argptr
);
52 static char *locate_first_half (char **argptr
, int *is_quote_enclosed
);
54 static struct symtabs_and_lines
decode_objc (char **argptr
,
56 struct symtab
*file_symtab
,
60 static struct symtabs_and_lines
decode_compound (char **argptr
,
66 static struct symbol
*lookup_prefix_sym (char **argptr
, char *p
);
68 static struct symtabs_and_lines
find_method (int funfirstline
,
73 struct symbol
*sym_class
);
75 static int collect_methods (char *copy
, struct type
*t
,
76 struct symbol
**sym_arr
);
78 static NORETURN
void cplusplus_error (const char *name
,
80 ATTR_NORETURN
ATTR_FORMAT (printf
, 2, 3);
82 static int total_number_of_methods (struct type
*type
);
84 static int find_methods (struct type
*, char *, struct symbol
**);
86 static int add_matching_methods (int method_counter
, struct type
*t
,
87 struct symbol
**sym_arr
);
89 static int add_constructors (int method_counter
, struct type
*t
,
90 struct symbol
**sym_arr
);
92 static void build_canonical_line_spec (struct symtab_and_line
*,
95 static char *find_toplevel_char (char *s
, char c
);
97 static struct symtabs_and_lines
decode_line_2 (struct symbol
*[],
100 static struct symtab
*symtab_from_filename (char **argptr
,
101 char *p
, int is_quote_enclosed
);
104 symtabs_and_lines
decode_all_digits (char **argptr
,
105 struct symtab
*default_symtab
,
108 struct symtab
*file_symtab
,
111 static struct symtabs_and_lines
decode_dollar (char *copy
,
113 struct symtab
*default_symtab
,
115 struct symtab
*file_symtab
);
117 static struct symtabs_and_lines
decode_variable (char *copy
,
120 struct symtab
*file_symtab
);
123 symtabs_and_lines
symbol_found (int funfirstline
,
127 struct symtab
*file_symtab
,
128 struct symtab
*sym_symtab
);
131 symtabs_and_lines
minsym_found (int funfirstline
,
132 struct minimal_symbol
*msymbol
);
134 /* Helper functions. */
136 /* Issue a helpful hint on using the command completion feature on
137 single quoted demangled C++ symbols as part of the completion
141 cplusplus_error (const char *name
, const char *fmt
, ...)
143 struct ui_file
*tmp_stream
;
144 tmp_stream
= mem_fileopen ();
145 make_cleanup_ui_file_delete (tmp_stream
);
149 va_start (args
, fmt
);
150 vfprintf_unfiltered (tmp_stream
, fmt
, args
);
154 while (*name
== '\'')
156 fprintf_unfiltered (tmp_stream
,
157 ("Hint: try '%s<TAB> or '%s<ESC-?>\n"
158 "(Note leading single quote.)"),
160 error_stream (tmp_stream
);
163 /* Return the number of methods described for TYPE, including the
164 methods from types it derives from. This can't be done in the symbol
165 reader because the type of the baseclass might still be stubbed
166 when the definition of the derived class is parsed. */
169 total_number_of_methods (struct type
*type
)
174 CHECK_TYPEDEF (type
);
175 if (TYPE_CPLUS_SPECIFIC (type
) == NULL
)
177 count
= TYPE_NFN_FIELDS_TOTAL (type
);
179 for (n
= 0; n
< TYPE_N_BASECLASSES (type
); n
++)
180 count
+= total_number_of_methods (TYPE_BASECLASS (type
, n
));
185 /* Recursive helper function for decode_line_1.
186 Look for methods named NAME in type T.
187 Return number of matches.
188 Put matches in SYM_ARR, which should have been allocated with
189 a size of total_number_of_methods (T) * sizeof (struct symbol *).
190 Note that this function is g++ specific. */
193 find_methods (struct type
*t
, char *name
, struct symbol
**sym_arr
)
197 char *class_name
= type_name_no_tag (t
);
199 /* Ignore this class if it doesn't have a name. This is ugly, but
200 unless we figure out how to get the physname without the name of
201 the class, then the loop can't do any good. */
203 && (lookup_symbol (class_name
, (struct block
*) NULL
,
204 STRUCT_DOMAIN
, (int *) NULL
,
205 (struct symtab
**) NULL
)))
208 int name_len
= strlen (name
);
212 /* Loop over each method name. At this level, all overloads of a name
213 are counted as a single name. There is an inner loop which loops over
216 for (method_counter
= TYPE_NFN_FIELDS (t
) - 1;
220 char *method_name
= TYPE_FN_FIELDLIST_NAME (t
, method_counter
);
223 if (strncmp (method_name
, "__", 2) == 0 ||
224 strncmp (method_name
, "op", 2) == 0 ||
225 strncmp (method_name
, "type", 4) == 0)
227 if (cplus_demangle_opname (method_name
, dem_opname
, DMGL_ANSI
))
228 method_name
= dem_opname
;
229 else if (cplus_demangle_opname (method_name
, dem_opname
, 0))
230 method_name
= dem_opname
;
233 if (strcmp_iw (name
, method_name
) == 0)
234 /* Find all the overloaded methods with that name. */
235 i1
+= add_matching_methods (method_counter
, t
,
237 else if (strncmp (class_name
, name
, name_len
) == 0
238 && (class_name
[name_len
] == '\0'
239 || class_name
[name_len
] == '<'))
240 i1
+= add_constructors (method_counter
, t
,
245 /* Only search baseclasses if there is no match yet, since names in
246 derived classes override those in baseclasses.
248 FIXME: The above is not true; it is only true of member functions
249 if they have the same number of arguments (??? - section 13.1 of the
250 ARM says the function members are not in the same scope but doesn't
251 really spell out the rules in a way I understand. In any case, if
252 the number of arguments differ this is a case in which we can overload
253 rather than hiding without any problem, and gcc 2.4.5 does overload
254 rather than hiding in this case). */
257 for (ibase
= 0; ibase
< TYPE_N_BASECLASSES (t
); ibase
++)
258 i1
+= find_methods (TYPE_BASECLASS (t
, ibase
), name
, sym_arr
+ i1
);
263 /* Add the symbols associated to methods of the class whose type is T
264 and whose name matches the method indexed by METHOD_COUNTER in the
265 array SYM_ARR. Return the number of methods added. */
268 add_matching_methods (int method_counter
, struct type
*t
,
269 struct symbol
**sym_arr
)
274 for (field_counter
= TYPE_FN_FIELDLIST_LENGTH (t
, method_counter
) - 1;
281 f
= TYPE_FN_FIELDLIST1 (t
, method_counter
);
283 if (TYPE_FN_FIELD_STUB (f
, field_counter
))
287 tmp_name
= gdb_mangle_name (t
,
290 phys_name
= alloca (strlen (tmp_name
) + 1);
291 strcpy (phys_name
, tmp_name
);
295 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, field_counter
);
297 /* Destructor is handled by caller, don't add it to
299 if (is_destructor_name (phys_name
) != 0)
302 sym_arr
[i1
] = lookup_symbol (phys_name
,
305 (struct symtab
**) NULL
);
310 /* This error message gets printed, but the method
311 still seems to be found
312 fputs_filtered("(Cannot find method ", gdb_stdout);
313 fprintf_symbol_filtered (gdb_stdout, phys_name,
315 DMGL_PARAMS | DMGL_ANSI);
316 fputs_filtered(" - possibly inlined.)\n", gdb_stdout);
324 /* Add the symbols associated to constructors of the class whose type
325 is CLASS_TYPE and which are indexed by by METHOD_COUNTER to the
326 array SYM_ARR. Return the number of methods added. */
329 add_constructors (int method_counter
, struct type
*t
,
330 struct symbol
**sym_arr
)
335 /* For GCC 3.x and stabs, constructors and destructors
336 have names like __base_ctor and __complete_dtor.
337 Check the physname for now if we're looking for a
340 = TYPE_FN_FIELDLIST_LENGTH (t
, method_counter
) - 1;
347 f
= TYPE_FN_FIELDLIST1 (t
, method_counter
);
349 /* GCC 3.x will never produce stabs stub methods, so
350 we don't need to handle this case. */
351 if (TYPE_FN_FIELD_STUB (f
, field_counter
))
353 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, field_counter
);
354 if (! is_constructor_name (phys_name
))
357 /* If this method is actually defined, include it in the
359 sym_arr
[i1
] = lookup_symbol (phys_name
,
362 (struct symtab
**) NULL
);
370 /* Helper function for decode_line_1.
371 Build a canonical line spec in CANONICAL if it is non-NULL and if
372 the SAL has a symtab.
373 If SYMNAME is non-NULL the canonical line spec is `filename:symname'.
374 If SYMNAME is NULL the line number from SAL is used and the canonical
375 line spec is `filename:linenum'. */
378 build_canonical_line_spec (struct symtab_and_line
*sal
, char *symname
,
381 char **canonical_arr
;
382 char *canonical_name
;
384 struct symtab
*s
= sal
->symtab
;
386 if (s
== (struct symtab
*) NULL
387 || s
->filename
== (char *) NULL
388 || canonical
== (char ***) NULL
)
391 canonical_arr
= (char **) xmalloc (sizeof (char *));
392 *canonical
= canonical_arr
;
394 filename
= s
->filename
;
397 canonical_name
= xmalloc (strlen (filename
) + strlen (symname
) + 2);
398 sprintf (canonical_name
, "%s:%s", filename
, symname
);
402 canonical_name
= xmalloc (strlen (filename
) + 30);
403 sprintf (canonical_name
, "%s:%d", filename
, sal
->line
);
405 canonical_arr
[0] = canonical_name
;
410 /* Find an instance of the character C in the string S that is outside
411 of all parenthesis pairs, single-quoted strings, and double-quoted
412 strings. Also, ignore the char within a template name, like a ','
413 within foo<int, int>. */
416 find_toplevel_char (char *s
, char c
)
418 int quoted
= 0; /* zero if we're not in quotes;
419 '"' if we're in a double-quoted string;
420 '\'' if we're in a single-quoted string. */
421 int depth
= 0; /* Number of unclosed parens we've seen. */
424 for (scan
= s
; *scan
; scan
++)
430 else if (*scan
== '\\' && *(scan
+ 1))
433 else if (*scan
== c
&& ! quoted
&& depth
== 0)
435 else if (*scan
== '"' || *scan
== '\'')
437 else if (*scan
== '(' || *scan
== '<')
439 else if ((*scan
== ')' || *scan
== '>') && depth
> 0)
446 /* Given a list of NELTS symbols in SYM_ARR, return a list of lines to
447 operate on (ask user if necessary).
448 If CANONICAL is non-NULL return a corresponding array of mangled names
449 as canonical line specs there. */
451 static struct symtabs_and_lines
452 decode_line_2 (struct symbol
*sym_arr
[], int nelts
, int funfirstline
,
455 struct symtabs_and_lines values
, return_values
;
460 struct cleanup
*old_chain
;
461 char **canonical_arr
= (char **) NULL
;
463 values
.sals
= (struct symtab_and_line
*)
464 alloca (nelts
* sizeof (struct symtab_and_line
));
465 return_values
.sals
= (struct symtab_and_line
*)
466 xmalloc (nelts
* sizeof (struct symtab_and_line
));
467 old_chain
= make_cleanup (xfree
, return_values
.sals
);
471 canonical_arr
= (char **) xmalloc (nelts
* sizeof (char *));
472 make_cleanup (xfree
, canonical_arr
);
473 memset (canonical_arr
, 0, nelts
* sizeof (char *));
474 *canonical
= canonical_arr
;
478 printf_unfiltered ("[0] cancel\n[1] all\n");
481 init_sal (&return_values
.sals
[i
]); /* Initialize to zeroes. */
482 init_sal (&values
.sals
[i
]);
483 if (sym_arr
[i
] && SYMBOL_CLASS (sym_arr
[i
]) == LOC_BLOCK
)
485 values
.sals
[i
] = find_function_start_sal (sym_arr
[i
], funfirstline
);
486 if (values
.sals
[i
].symtab
)
487 printf_unfiltered ("[%d] %s at %s:%d\n",
489 SYMBOL_PRINT_NAME (sym_arr
[i
]),
490 values
.sals
[i
].symtab
->filename
,
491 values
.sals
[i
].line
);
493 printf_unfiltered ("[%d] %s at ?FILE:%d [No symtab? Probably broken debug info...]\n",
495 SYMBOL_PRINT_NAME (sym_arr
[i
]),
496 values
.sals
[i
].line
);
500 printf_unfiltered ("?HERE\n");
504 prompt
= getenv ("PS2");
509 args
= command_line_input (prompt
, 0, "overload-choice");
511 if (args
== 0 || *args
== 0)
512 error_no_arg ("one or more choice numbers");
520 while (*arg1
>= '0' && *arg1
<= '9')
522 if (*arg1
&& *arg1
!= ' ' && *arg1
!= '\t')
523 error ("Arguments must be choice numbers.");
533 for (i
= 0; i
< nelts
; i
++)
535 if (canonical_arr
[i
] == NULL
)
537 symname
= DEPRECATED_SYMBOL_NAME (sym_arr
[i
]);
538 canonical_arr
[i
] = savestring (symname
, strlen (symname
));
542 memcpy (return_values
.sals
, values
.sals
,
543 (nelts
* sizeof (struct symtab_and_line
)));
544 return_values
.nelts
= nelts
;
545 discard_cleanups (old_chain
);
546 return return_values
;
549 if (num
>= nelts
+ 2)
551 printf_unfiltered ("No choice number %d.\n", num
);
556 if (values
.sals
[num
].pc
)
560 symname
= DEPRECATED_SYMBOL_NAME (sym_arr
[num
]);
561 make_cleanup (xfree
, symname
);
562 canonical_arr
[i
] = savestring (symname
, strlen (symname
));
564 return_values
.sals
[i
++] = values
.sals
[num
];
565 values
.sals
[num
].pc
= 0;
569 printf_unfiltered ("duplicate request for %d ignored.\n", num
);
574 while (*args
== ' ' || *args
== '\t')
577 return_values
.nelts
= i
;
578 discard_cleanups (old_chain
);
579 return return_values
;
582 /* The parser of linespec itself. */
584 /* Parse a string that specifies a line number.
585 Pass the address of a char * variable; that variable will be
586 advanced over the characters actually parsed.
590 LINENUM -- that line number in current file. PC returned is 0.
591 FILE:LINENUM -- that line in that file. PC returned is 0.
592 FUNCTION -- line number of openbrace of that function.
593 PC returned is the start of the function.
594 VARIABLE -- line number of definition of that variable.
596 FILE:FUNCTION -- likewise, but prefer functions in that file.
597 *EXPR -- line in which address EXPR appears.
599 This may all be followed by an "if EXPR", which we ignore.
601 FUNCTION may be an undebuggable function found in minimal symbol table.
603 If the argument FUNFIRSTLINE is nonzero, we want the first line
604 of real code inside a function when a function is specified, and it is
605 not OK to specify a variable or type to get its line number.
607 DEFAULT_SYMTAB specifies the file to use if none is specified.
608 It defaults to current_source_symtab.
609 DEFAULT_LINE specifies the line number to use for relative
610 line numbers (that start with signs). Defaults to current_source_line.
611 If CANONICAL is non-NULL, store an array of strings containing the canonical
612 line specs there if necessary. Currently overloaded member functions and
613 line numbers or static functions without a filename yield a canonical
614 line spec. The array and the line spec strings are allocated on the heap,
615 it is the callers responsibility to free them.
617 Note that it is possible to return zero for the symtab
618 if no file is validly specified. Callers must check that.
619 Also, the line number returned may be invalid. */
621 /* We allow single quotes in various places. This is a hideous
622 kludge, which exists because the completer can't yet deal with the
623 lack of single quotes. FIXME: write a linespec_completer which we
624 can use as appropriate instead of make_symbol_completion_list. */
626 struct symtabs_and_lines
627 decode_line_1 (char **argptr
, int funfirstline
, struct symtab
*default_symtab
,
628 int default_line
, char ***canonical
)
632 /* If a file name is specified, this is its symtab. */
633 struct symtab
*file_symtab
= NULL
;
636 /* This is NULL if there are no parens in *ARGPTR, or a pointer to
637 the closing parenthesis if there are parens. */
639 /* This says whether or not something in *ARGPTR is quoted with
640 completer_quotes (i.e. with single quotes). */
642 /* Is part of *ARGPTR is enclosed in double quotes? */
643 int is_quote_enclosed
;
644 int is_objc_method
= 0;
645 char *saved_arg
= *argptr
;
647 /* Defaults have defaults. */
649 initialize_defaults (&default_symtab
, &default_line
);
651 /* See if arg is *PC. */
654 return decode_indirect (argptr
);
656 /* Set various flags. 'paren_pointer' is important for overload
657 checking, where we allow things like:
658 (gdb) break c::f(int)
661 set_flags (*argptr
, &is_quoted
, &paren_pointer
);
663 /* Check to see if it's a multipart linespec (with colons or
666 /* Locate the end of the first half of the linespec. */
668 p
= locate_first_half (argptr
, &is_quote_enclosed
);
670 /* Check if this is an Objective-C method (anything that starts with
671 a '+' or '-' and a '['). */
672 if (*p
&& (p
[0] == ':') && (strchr ("+-", p
[1]) != NULL
)
676 paren_pointer
= NULL
; /* Just a category name. Ignore it. */
679 /* Check if the symbol could be an Objective-C selector. */
682 struct symtabs_and_lines values
;
683 values
= decode_objc (argptr
, funfirstline
, NULL
,
684 canonical
, saved_arg
);
685 if (values
.sals
!= NULL
)
689 /* Does it look like there actually were two parts? */
691 if ((p
[0] == ':' || p
[0] == '.') && paren_pointer
== NULL
)
694 *argptr
= *argptr
+ 1;
696 /* Is it a C++ or Java compound data structure? */
698 if (p
[0] == '.' || p
[1] == ':')
699 return decode_compound (argptr
, funfirstline
, canonical
,
702 /* No, the first part is a filename; set s to be that file's
703 symtab. Also, move argptr past the filename. */
705 file_symtab
= symtab_from_filename (argptr
, p
, is_quote_enclosed
);
708 /* No one really seems to know why this was added. It certainly
709 breaks the command line, though, whenever the passed
710 name is of the form ClassName::Method. This bit of code
711 singles out the class name, and if funfirstline is set (for
712 example, you are setting a breakpoint at this function),
713 you get an error. This did not occur with earlier
714 verions, so I am ifdef'ing this out. 3/29/99 */
717 /* Check if what we have till now is a symbol name */
719 /* We may be looking at a template instantiation such
720 as "foo<int>". Check here whether we know about it,
721 instead of falling through to the code below which
722 handles ordinary function names, because that code
723 doesn't like seeing '<' and '>' in a name -- the
724 skip_quoted call doesn't go past them. So see if we
725 can figure it out right now. */
727 copy
= (char *) alloca (p
- *argptr
+ 1);
728 memcpy (copy
, *argptr
, p
- *argptr
);
729 copy
[p
- *argptr
] = '\000';
730 sym
= lookup_symbol (copy
, 0, VAR_DOMAIN
, 0, &sym_symtab
);
733 *argptr
= (*p
== '\'') ? p
+ 1 : p
;
734 return symbol_found (funfirstline
, canonical
, copy
, sym
,
737 /* Otherwise fall out from here and go to file/line spec
742 /* S is specified file's symtab, or 0 if no file specified.
743 arg no longer contains the file name. */
745 /* Check whether arg is all digits (and sign). */
748 if (*q
== '-' || *q
== '+')
750 while (*q
>= '0' && *q
<= '9')
753 if (q
!= *argptr
&& (*q
== 0 || *q
== ' ' || *q
== '\t' || *q
== ','))
754 /* We found a token consisting of all digits -- at least one digit. */
755 return decode_all_digits (argptr
, default_symtab
, default_line
,
756 canonical
, file_symtab
, q
);
758 /* Arg token is not digits => try it as a variable name
759 Find the next token (everything up to end or next whitespace). */
761 if (**argptr
== '$') /* May be a convenience variable. */
762 /* One or two $ chars possible. */
763 p
= skip_quoted (*argptr
+ (((*argptr
)[1] == '$') ? 2 : 1));
766 p
= skip_quoted (*argptr
);
768 error ("Unmatched single quote.");
770 else if (is_objc_method
)
772 /* allow word separators in method names for Obj-C */
773 p
= skip_quoted_chars (*argptr
, NULL
, "");
775 else if (paren_pointer
!= NULL
)
777 p
= paren_pointer
+ 1;
781 p
= skip_quoted (*argptr
);
784 copy
= (char *) alloca (p
- *argptr
+ 1);
785 memcpy (copy
, *argptr
, p
- *argptr
);
786 copy
[p
- *argptr
] = '\0';
789 && copy
[0] == copy
[p
- *argptr
- 1]
790 && strchr (get_gdb_completer_quote_characters (), copy
[0]) != NULL
)
792 copy
[p
- *argptr
- 1] = '\0';
795 while (*p
== ' ' || *p
== '\t')
799 /* If it starts with $: may be a legitimate variable or routine name
800 (e.g. HP-UX millicode routines such as $$dyncall), or it may
801 be history value, or it may be a convenience variable. */
804 return decode_dollar (copy
, funfirstline
, default_symtab
,
805 canonical
, file_symtab
);
807 /* Look up that token as a variable.
808 If file specified, use that file's per-file block to start with. */
810 return decode_variable (copy
, funfirstline
, canonical
, file_symtab
);
815 /* Now, more helper functions for decode_line_1. Some conventions
816 that these functions follow:
818 Decode_line_1 typically passes along some of its arguments or local
819 variables to the subfunctions. It passes the variables by
820 reference if they are modified by the subfunction, and by value
823 Some of the functions have side effects that don't arise from
824 variables that are passed by reference. In particular, if a
825 function is passed ARGPTR as an argument, it modifies what ARGPTR
826 points to; typically, it advances *ARGPTR past whatever substring
827 it has just looked at. (If it doesn't modify *ARGPTR, then the
828 function gets passed *ARGPTR instead, which is then called ARG: see
829 set_flags, for example.) Also, functions that return a struct
830 symtabs_and_lines may modify CANONICAL, as in the description of
833 If a function returns a struct symtabs_and_lines, then that struct
834 will immediately make its way up the call chain to be returned by
835 decode_line_1. In particular, all of the functions decode_XXX
836 calculate the appropriate struct symtabs_and_lines, under the
837 assumption that their argument is of the form XXX. */
839 /* First, some functions to initialize stuff at the beggining of the
843 initialize_defaults (struct symtab
**default_symtab
, int *default_line
)
845 if (*default_symtab
== 0)
847 /* Use whatever we have for the default source line. We don't use
848 get_current_or_default_symtab_and_line as it can recurse and call
850 struct symtab_and_line cursal
=
851 get_current_source_symtab_and_line ();
853 *default_symtab
= cursal
.symtab
;
854 *default_line
= cursal
.line
;
859 set_flags (char *arg
, int *is_quoted
, char **paren_pointer
)
864 /* 'has_if' is for the syntax:
865 (gdb) break foo if (a==b)
867 if ((ii
= strstr (arg
, " if ")) != NULL
||
868 (ii
= strstr (arg
, "\tif ")) != NULL
||
869 (ii
= strstr (arg
, " if\t")) != NULL
||
870 (ii
= strstr (arg
, "\tif\t")) != NULL
||
871 (ii
= strstr (arg
, " if(")) != NULL
||
872 (ii
= strstr (arg
, "\tif( ")) != NULL
)
874 /* Temporarily zap out "if (condition)" to not confuse the
875 parenthesis-checking code below. This is undone below. Do not
883 && strchr (get_gdb_completer_quote_characters (),
886 *paren_pointer
= strchr (arg
, '(');
887 if (*paren_pointer
!= NULL
)
888 *paren_pointer
= strrchr (*paren_pointer
, ')');
890 /* Now that we're safely past the paren_pointer check, put back " if
891 (condition)" so outer layers can see it. */
898 /* Decode arg of the form *PC. */
900 static struct symtabs_and_lines
901 decode_indirect (char **argptr
)
903 struct symtabs_and_lines values
;
907 pc
= parse_and_eval_address_1 (argptr
);
909 values
.sals
= (struct symtab_and_line
*)
910 xmalloc (sizeof (struct symtab_and_line
));
913 values
.sals
[0] = find_pc_line (pc
, 0);
914 values
.sals
[0].pc
= pc
;
915 values
.sals
[0].section
= find_pc_overlay (pc
);
922 /* Locate the first half of the linespec, ending in a colon, period,
923 or whitespace. (More or less.) Also, check to see if *ARGPTR is
924 enclosed in double quotes; if so, set is_quote_enclosed, advance
925 ARGPTR past that and zero out the trailing double quote. */
928 locate_first_half (char **argptr
, int *is_quote_enclosed
)
934 /* Maybe we were called with a line range FILENAME:LINENUM,FILENAME:LINENUM
935 and we must isolate the first half. Outer layers will call again later
938 Don't count commas that appear in argument lists of overloaded
939 functions, or in quoted strings. It's stupid to go to this much
940 trouble when the rest of the function is such an obvious roach hotel. */
941 ii
= find_toplevel_char (*argptr
, ',');
942 has_comma
= (ii
!= 0);
944 /* Temporarily zap out second half to not confuse the code below.
945 This is undone below. Do not change ii!! */
951 /* Maybe arg is FILE : LINENUM or FILE : FUNCTION. May also be
952 CLASS::MEMBER, or NAMESPACE::NAME. Look for ':', but ignore
958 *is_quote_enclosed
= 1;
963 *is_quote_enclosed
= 0;
968 char *temp_end
= find_template_name_end (p
);
970 error ("malformed template specification in command");
973 /* Check for a colon and a plus or minus and a [ (which
974 indicates an Objective-C method) */
975 if (*p
&& (p
[0] == ':') && (strchr ("+-", p
[1]) != NULL
)
980 /* Check for the end of the first half of the linespec. End of
981 line, a tab, a double colon or the last single colon, or a
982 space. But if enclosed in double quotes we do not break on
987 && ((p
[1] == ':') || (strchr (p
+ 1, ':') == NULL
)))
988 || ((p
[0] == ' ') && !*is_quote_enclosed
))
990 if (p
[0] == '.' && strchr (p
, ':') == NULL
)
992 /* Java qualified method. Find the *last* '.', since the
993 others are package qualifiers. */
994 for (p1
= p
; *p1
; p1
++)
1002 while (p
[0] == ' ' || p
[0] == '\t')
1005 /* If the closing double quote was left at the end, remove it. */
1006 if (*is_quote_enclosed
)
1008 char *closing_quote
= strchr (p
- 1, '"');
1009 if (closing_quote
&& closing_quote
[1] == '\0')
1010 *closing_quote
= '\0';
1013 /* Now that we've safely parsed the first half, put back ',' so
1014 outer layers can see it. */
1023 /* Here's where we recognise an Objective-C Selector. An Objective C
1024 selector may be implemented by more than one class, therefore it
1025 may represent more than one method/function. This gives us a
1026 situation somewhat analogous to C++ overloading. If there's more
1027 than one method that could represent the selector, then use some of
1028 the existing C++ code to let the user choose one. */
1030 struct symtabs_and_lines
1031 decode_objc (char **argptr
, int funfirstline
, struct symtab
*file_symtab
,
1032 char ***canonical
, char *saved_arg
)
1034 struct symtabs_and_lines values
;
1035 struct symbol
**sym_arr
= NULL
;
1036 struct symbol
*sym
= NULL
;
1038 struct block
*block
= NULL
;
1045 if (file_symtab
!= NULL
)
1046 block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (file_symtab
), STATIC_BLOCK
);
1048 block
= get_selected_block (0);
1050 copy
= find_imps (file_symtab
, block
, *argptr
, NULL
, &i1
, &i2
);
1054 sym_arr
= (struct symbol
**) alloca ((i1
+ 1) * sizeof (struct symbol
*));
1057 copy
= find_imps (file_symtab
, block
, *argptr
, sym_arr
, &i1
, &i2
);
1061 /* i1 now represents the TOTAL number of matches found.
1062 i2 represents how many HIGH-LEVEL (struct symbol) matches,
1063 which will come first in the sym_arr array. Any low-level
1064 (minimal_symbol) matches will follow those. */
1070 /* Already a struct symbol. */
1075 sym
= find_pc_function (SYMBOL_VALUE_ADDRESS (sym_arr
[0]));
1076 if ((sym
!= NULL
) && strcmp (SYMBOL_LINKAGE_NAME (sym_arr
[0]), SYMBOL_LINKAGE_NAME (sym
)) != 0)
1078 warning ("debugging symbol \"%s\" does not match selector; ignoring", SYMBOL_LINKAGE_NAME (sym
));
1083 values
.sals
= (struct symtab_and_line
*) xmalloc (sizeof (struct symtab_and_line
));
1086 if (sym
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
)
1088 /* Canonicalize this, so it remains resolved for dylib loads. */
1089 values
.sals
[0] = find_function_start_sal (sym
, funfirstline
);
1090 build_canonical_line_spec (values
.sals
, SYMBOL_NATURAL_NAME (sym
), canonical
);
1094 /* The only match was a non-debuggable symbol. */
1095 values
.sals
[0].symtab
= 0;
1096 values
.sals
[0].line
= 0;
1097 values
.sals
[0].end
= 0;
1098 values
.sals
[0].pc
= SYMBOL_VALUE_ADDRESS (sym_arr
[0]);
1105 /* More than one match. The user must choose one or more. */
1106 return decode_line_2 (sym_arr
, i2
, funfirstline
, canonical
);
1112 /* This handles C++ and Java compound data structures. P should point
1113 at the first component separator, i.e. double-colon or period. */
1115 static struct symtabs_and_lines
1116 decode_compound (char **argptr
, int funfirstline
, char ***canonical
,
1117 char *saved_arg
, char *p
)
1119 struct symtabs_and_lines values
;
1124 char *saved_arg2
= *argptr
;
1127 /* The symtab that SYM was found in. */
1128 struct symtab
*sym_symtab
;
1130 struct symbol
*sym_class
;
1131 struct symbol
**sym_arr
;
1134 /* First check for "global" namespace specification,
1135 of the form "::foo". If found, skip over the colons
1136 and jump to normal symbol processing. */
1138 && ((*argptr
== p
) || (p
[-1] == ' ') || (p
[-1] == '\t')))
1141 /* We have what looks like a class or namespace
1142 scope specification (A::B), possibly with many
1143 levels of namespaces or classes (A::B::C::D).
1145 Some versions of the HP ANSI C++ compiler (as also possibly
1146 other compilers) generate class/function/member names with
1147 embedded double-colons if they are inside namespaces. To
1148 handle this, we loop a few times, considering larger and
1149 larger prefixes of the string as though they were single
1150 symbols. So, if the initially supplied string is
1151 A::B::C::D::foo, we have to look up "A", then "A::B",
1152 then "A::B::C", then "A::B::C::D", and finally
1153 "A::B::C::D::foo" as single, monolithic symbols, because
1154 A, B, C or D may be namespaces.
1156 Note that namespaces can nest only inside other
1157 namespaces, and not inside classes. So we need only
1158 consider *prefixes* of the string; there is no need to look up
1159 "B::C" separately as a symbol in the previous example. */
1161 p2
= p
; /* Save for restart. */
1164 sym_class
= lookup_prefix_sym (argptr
, p
);
1167 (t
= check_typedef (SYMBOL_TYPE (sym_class
)),
1168 (TYPE_CODE (t
) == TYPE_CODE_STRUCT
1169 || TYPE_CODE (t
) == TYPE_CODE_UNION
)))
1171 /* Arg token is not digits => try it as a function name.
1172 Find the next token (everything up to end or next
1175 && strchr (get_gdb_completer_quote_characters (),
1178 p
= skip_quoted (*argptr
);
1179 *argptr
= *argptr
+ 1;
1184 while (*p
&& *p
!= ' ' && *p
!= '\t' && *p
!= ',' && *p
!= ':')
1188 q = operator_chars (*argptr, &q1);
1192 char *tmp = alloca (q1 - q + 1);
1193 memcpy (tmp, q, q1 - q);
1195 opname = cplus_mangle_opname (tmp, DMGL_ANSI);
1198 cplusplus_error (saved_arg, "no mangling for \"%s\"\n", tmp);
1200 copy = (char*) alloca (3 + strlen(opname));
1201 sprintf (copy, "__%s", opname);
1207 copy
= (char *) alloca (p
- *argptr
+ 1);
1208 memcpy (copy
, *argptr
, p
- *argptr
);
1209 copy
[p
- *argptr
] = '\0';
1211 && copy
[p
- *argptr
- 1]
1212 && strchr (get_gdb_completer_quote_characters (),
1213 copy
[p
- *argptr
- 1]) != NULL
)
1214 copy
[p
- *argptr
- 1] = '\0';
1217 /* No line number may be specified. */
1218 while (*p
== ' ' || *p
== '\t')
1222 return find_method (funfirstline
, canonical
, saved_arg
,
1223 copy
, t
, sym_class
);
1226 /* Move pointer up to next possible class/namespace token. */
1227 p
= p2
+ 1; /* Restart with old value +1. */
1228 /* Move pointer ahead to next double-colon. */
1229 while (*p
&& (p
[0] != ' ') && (p
[0] != '\t') && (p
[0] != '\''))
1233 temp_end
= find_template_name_end (p
);
1235 error ("malformed template specification in command");
1238 else if ((p
[0] == ':') && (p
[1] == ':'))
1239 break; /* Found double-colon. */
1245 break; /* Out of the while (1). */
1247 p2
= p
; /* Save restart for next time around. */
1248 *argptr
= saved_arg2
; /* Restore argptr. */
1251 /* Last chance attempt -- check entire name as a symbol. Use "copy"
1252 in preparation for jumping out of this block, to be consistent
1253 with usage following the jump target. */
1254 copy
= (char *) alloca (p
- saved_arg2
+ 1);
1255 memcpy (copy
, saved_arg2
, p
- saved_arg2
);
1256 /* Note: if is_quoted should be true, we snuff out quote here
1258 copy
[p
- saved_arg2
] = '\000';
1259 /* Set argptr to skip over the name. */
1260 *argptr
= (*p
== '\'') ? p
+ 1 : p
;
1261 /* Look up entire name */
1262 sym
= lookup_symbol (copy
, 0, VAR_DOMAIN
, 0, &sym_symtab
);
1264 return symbol_found (funfirstline
, canonical
, copy
, sym
,
1267 /* Couldn't find any interpretation as classes/namespaces, so give
1268 up. The quotes are important if copy is empty. */
1269 cplusplus_error (saved_arg
,
1270 "Can't find member of namespace, class, struct, or union named \"%s\"\n",
1274 /* Next come some helper functions for decode_compound. */
1276 /* Return the symbol corresponding to the substring of *ARGPTR ending
1277 at P, allowing whitespace. Also, advance *ARGPTR past the symbol
1278 name in question, the compound object separator ("::" or "."), and
1281 static struct symbol
*
1282 lookup_prefix_sym (char **argptr
, char *p
)
1287 /* Extract the class name. */
1289 while (p
!= *argptr
&& p
[-1] == ' ')
1291 copy
= (char *) alloca (p
- *argptr
+ 1);
1292 memcpy (copy
, *argptr
, p
- *argptr
);
1293 copy
[p
- *argptr
] = 0;
1295 /* Discard the class name from the arg. */
1296 p
= p1
+ (p1
[0] == ':' ? 2 : 1);
1297 while (*p
== ' ' || *p
== '\t')
1301 return lookup_symbol (copy
, 0, STRUCT_DOMAIN
, 0,
1302 (struct symtab
**) NULL
);
1305 /* This finds the method COPY in the class whose type is T and whose
1306 symbol is SYM_CLASS. */
1308 static struct symtabs_and_lines
1309 find_method (int funfirstline
, char ***canonical
, char *saved_arg
,
1310 char *copy
, struct type
*t
, struct symbol
*sym_class
)
1312 struct symtabs_and_lines values
;
1313 struct symbol
*sym
= 0;
1314 int i1
; /* Counter for the symbol array. */
1315 struct symbol
**sym_arr
= alloca (total_number_of_methods (t
)
1316 * sizeof (struct symbol
*));
1318 /* Find all methods with a matching name, and put them in
1321 i1
= collect_methods (copy
, t
, sym_arr
);
1325 /* There is exactly one field with that name. */
1328 if (sym
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
)
1330 values
.sals
= (struct symtab_and_line
*)
1331 xmalloc (sizeof (struct symtab_and_line
));
1333 values
.sals
[0] = find_function_start_sal (sym
,
1344 /* There is more than one field with that name
1345 (overloaded). Ask the user which one to use. */
1346 return decode_line_2 (sym_arr
, i1
, funfirstline
, canonical
);
1352 if (is_operator_name (copy
))
1354 tmp
= (char *) alloca (strlen (copy
+ 3) + 9);
1355 strcpy (tmp
, "operator ");
1356 strcat (tmp
, copy
+ 3);
1361 cplusplus_error (saved_arg
,
1362 "the class `%s' does not have destructor defined\n",
1363 SYMBOL_PRINT_NAME (sym_class
));
1365 cplusplus_error (saved_arg
,
1366 "the class %s does not have any method named %s\n",
1367 SYMBOL_PRINT_NAME (sym_class
), tmp
);
1371 /* Find all methods named COPY in the class whose type is T, and put
1372 them in SYM_ARR. Return the number of methods found. */
1375 collect_methods (char *copy
, struct type
*t
,
1376 struct symbol
**sym_arr
)
1378 int i1
= 0; /* Counter for the symbol array. */
1380 if (destructor_name_p (copy
, t
))
1382 /* Destructors are a special case. */
1383 int m_index
, f_index
;
1385 if (get_destructor_fn_field (t
, &m_index
, &f_index
))
1387 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, m_index
);
1390 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, f_index
),
1391 NULL
, VAR_DOMAIN
, (int *) NULL
,
1392 (struct symtab
**) NULL
);
1398 i1
= find_methods (t
, copy
, sym_arr
);
1405 /* Return the symtab associated to the filename given by the substring
1406 of *ARGPTR ending at P, and advance ARGPTR past that filename. */
1408 static struct symtab
*
1409 symtab_from_filename (char **argptr
, char *p
, int is_quote_enclosed
)
1413 struct symtab
*file_symtab
;
1416 while (p
!= *argptr
&& p
[-1] == ' ')
1418 if ((*p
== '"') && is_quote_enclosed
)
1420 copy
= (char *) alloca (p
- *argptr
+ 1);
1421 memcpy (copy
, *argptr
, p
- *argptr
);
1422 /* It may have the ending quote right after the file name. */
1423 if (is_quote_enclosed
&& copy
[p
- *argptr
- 1] == '"')
1424 copy
[p
- *argptr
- 1] = 0;
1426 copy
[p
- *argptr
] = 0;
1428 /* Find that file's data. */
1429 file_symtab
= lookup_symtab (copy
);
1430 if (file_symtab
== 0)
1432 if (!have_full_symbols () && !have_partial_symbols ())
1433 error ("No symbol table is loaded. Use the \"file\" command.");
1434 error ("No source file named %s.", copy
);
1437 /* Discard the file name from the arg. */
1439 while (*p
== ' ' || *p
== '\t')
1448 /* This decodes a line where the argument is all digits (possibly
1449 preceded by a sign). Q should point to the end of those digits;
1450 the other arguments are as usual. */
1452 static struct symtabs_and_lines
1453 decode_all_digits (char **argptr
, struct symtab
*default_symtab
,
1454 int default_line
, char ***canonical
,
1455 struct symtab
*file_symtab
, char *q
)
1458 struct symtabs_and_lines values
;
1459 struct symtab_and_line val
;
1467 /* We might need a canonical line spec if no file was specified. */
1468 int need_canonical
= (file_symtab
== 0) ? 1 : 0;
1472 /* This is where we need to make sure that we have good defaults.
1473 We must guarantee that this section of code is never executed
1474 when we are called with just a function name, since
1475 set_default_source_symtab_and_line uses
1476 select_source_symtab that calls us with such an argument. */
1478 if (file_symtab
== 0 && default_symtab
== 0)
1480 /* Make sure we have at least a default source file. */
1481 set_default_source_symtab_and_line ();
1482 initialize_defaults (&default_symtab
, &default_line
);
1485 if (**argptr
== '+')
1486 sign
= plus
, (*argptr
)++;
1487 else if (**argptr
== '-')
1488 sign
= minus
, (*argptr
)++;
1489 val
.line
= atoi (*argptr
);
1495 if (file_symtab
== 0)
1496 val
.line
= default_line
+ val
.line
;
1501 if (file_symtab
== 0)
1502 val
.line
= default_line
- val
.line
;
1507 break; /* No need to adjust val.line. */
1510 while (*q
== ' ' || *q
== '\t')
1513 if (file_symtab
== 0)
1514 file_symtab
= default_symtab
;
1516 /* It is possible that this source file has more than one symtab,
1517 and that the new line number specification has moved us from the
1518 default (in file_symtab) to a new one. */
1519 val
.symtab
= find_line_symtab (file_symtab
, val
.line
, NULL
, NULL
);
1520 if (val
.symtab
== 0)
1521 val
.symtab
= file_symtab
;
1524 values
.sals
= (struct symtab_and_line
*)
1525 xmalloc (sizeof (struct symtab_and_line
));
1526 values
.sals
[0] = val
;
1529 build_canonical_line_spec (values
.sals
, NULL
, canonical
);
1535 /* Decode a linespec starting with a dollar sign. */
1537 static struct symtabs_and_lines
1538 decode_dollar (char *copy
, int funfirstline
, struct symtab
*default_symtab
,
1539 char ***canonical
, struct symtab
*file_symtab
)
1543 int need_canonical
= 0;
1544 struct symtabs_and_lines values
;
1545 struct symtab_and_line val
;
1548 /* The symtab that SYM was found in. */
1549 struct symtab
*sym_symtab
;
1550 struct minimal_symbol
*msymbol
;
1552 p
= (copy
[1] == '$') ? copy
+ 2 : copy
+ 1;
1553 while (*p
>= '0' && *p
<= '9')
1555 if (!*p
) /* Reached end of token without hitting non-digit. */
1557 /* We have a value history reference. */
1558 sscanf ((copy
[1] == '$') ? copy
+ 2 : copy
+ 1, "%d", &index
);
1559 valx
= access_value_history ((copy
[1] == '$') ? -index
: index
);
1560 if (TYPE_CODE (VALUE_TYPE (valx
)) != TYPE_CODE_INT
)
1561 error ("History values used in line specs must have integer values.");
1565 /* Not all digits -- may be user variable/function or a
1566 convenience variable. */
1568 /* Look up entire name as a symbol first. */
1569 sym
= lookup_symbol (copy
, 0, VAR_DOMAIN
, 0, &sym_symtab
);
1570 file_symtab
= (struct symtab
*) 0;
1572 /* Symbol was found --> jump to normal symbol processing. */
1574 return symbol_found (funfirstline
, canonical
, copy
, sym
,
1577 /* If symbol was not found, look in minimal symbol tables. */
1578 msymbol
= lookup_minimal_symbol (copy
, NULL
, NULL
);
1579 /* Min symbol was found --> jump to minsym processing. */
1581 return minsym_found (funfirstline
, msymbol
);
1583 /* Not a user variable or function -- must be convenience variable. */
1584 need_canonical
= (file_symtab
== 0) ? 1 : 0;
1585 valx
= value_of_internalvar (lookup_internalvar (copy
+ 1));
1586 if (TYPE_CODE (VALUE_TYPE (valx
)) != TYPE_CODE_INT
)
1587 error ("Convenience variables used in line specs must have integer values.");
1592 /* Either history value or convenience value from above, in valx. */
1593 val
.symtab
= file_symtab
? file_symtab
: default_symtab
;
1594 val
.line
= value_as_long (valx
);
1597 values
.sals
= (struct symtab_and_line
*) xmalloc (sizeof val
);
1598 values
.sals
[0] = val
;
1602 build_canonical_line_spec (values
.sals
, NULL
, canonical
);
1609 /* Decode a linespec that's a variable. If FILE_SYMTAB is non-NULL,
1610 look in that symtab's static variables first. */
1612 static struct symtabs_and_lines
1613 decode_variable (char *copy
, int funfirstline
, char ***canonical
,
1614 struct symtab
*file_symtab
)
1617 /* The symtab that SYM was found in. */
1618 struct symtab
*sym_symtab
;
1620 struct minimal_symbol
*msymbol
;
1622 sym
= lookup_symbol (copy
,
1624 ? BLOCKVECTOR_BLOCK (BLOCKVECTOR (file_symtab
),
1626 : get_selected_block (0)),
1627 VAR_DOMAIN
, 0, &sym_symtab
);
1630 return symbol_found (funfirstline
, canonical
, copy
, sym
,
1631 file_symtab
, sym_symtab
);
1633 msymbol
= lookup_minimal_symbol (copy
, NULL
, NULL
);
1635 if (msymbol
!= NULL
)
1636 return minsym_found (funfirstline
, msymbol
);
1638 if (!have_full_symbols () &&
1639 !have_partial_symbols () && !have_minimal_symbols ())
1640 error ("No symbol table is loaded. Use the \"file\" command.");
1642 error ("Function \"%s\" not defined.", copy
);
1648 /* Now come some functions that are called from multiple places within
1651 /* We've found a symbol SYM to associate with our linespec; build a
1652 corresponding struct symtabs_and_lines. */
1654 static struct symtabs_and_lines
1655 symbol_found (int funfirstline
, char ***canonical
, char *copy
,
1656 struct symbol
*sym
, struct symtab
*file_symtab
,
1657 struct symtab
*sym_symtab
)
1659 struct symtabs_and_lines values
;
1661 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
1663 /* Arg is the name of a function */
1664 values
.sals
= (struct symtab_and_line
*)
1665 xmalloc (sizeof (struct symtab_and_line
));
1666 values
.sals
[0] = find_function_start_sal (sym
, funfirstline
);
1669 /* Don't use the SYMBOL_LINE; if used at all it points to
1670 the line containing the parameters or thereabouts, not
1671 the first line of code. */
1673 /* We might need a canonical line spec if it is a static
1675 if (file_symtab
== 0)
1677 struct blockvector
*bv
= BLOCKVECTOR (sym_symtab
);
1678 struct block
*b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1679 if (lookup_block_symbol (b
, copy
, NULL
, VAR_DOMAIN
) != NULL
)
1680 build_canonical_line_spec (values
.sals
, copy
, canonical
);
1687 error ("\"%s\" is not a function", copy
);
1688 else if (SYMBOL_LINE (sym
) != 0)
1690 /* We know its line number. */
1691 values
.sals
= (struct symtab_and_line
*)
1692 xmalloc (sizeof (struct symtab_and_line
));
1694 memset (&values
.sals
[0], 0, sizeof (values
.sals
[0]));
1695 values
.sals
[0].symtab
= sym_symtab
;
1696 values
.sals
[0].line
= SYMBOL_LINE (sym
);
1700 /* This can happen if it is compiled with a compiler which doesn't
1701 put out line numbers for variables. */
1702 /* FIXME: Shouldn't we just set .line and .symtab to zero
1703 and return? For example, "info line foo" could print
1705 error ("Line number not known for symbol \"%s\"", copy
);
1709 /* We've found a minimal symbol MSYMBOL to associate with our
1710 linespec; build a corresponding struct symtabs_and_lines. */
1712 static struct symtabs_and_lines
1713 minsym_found (int funfirstline
, struct minimal_symbol
*msymbol
)
1715 struct symtabs_and_lines values
;
1717 values
.sals
= (struct symtab_and_line
*)
1718 xmalloc (sizeof (struct symtab_and_line
));
1719 values
.sals
[0] = find_pc_sect_line (SYMBOL_VALUE_ADDRESS (msymbol
),
1720 (struct sec
*) 0, 0);
1721 values
.sals
[0].section
= SYMBOL_BFD_SECTION (msymbol
);
1724 values
.sals
[0].pc
+= FUNCTION_START_OFFSET
;
1725 values
.sals
[0].pc
= SKIP_PROLOGUE (values
.sals
[0].pc
);