#include "stack.h"
#include "location.h"
#include "common/function-view.h"
+#include "common/def-vector.h"
/* An enumeration of the various things a user might attempt to
complete for a linespec location. */
if (i != IF_KEYWORD_INDEX)
{
p += len;
- p = skip_spaces_const (p);
+ p = skip_spaces (p);
for (j = 0; linespec_keywords[j] != NULL; ++j)
{
int nextlen = strlen (linespec_keywords[j]);
{
if (isspace (*PARSER_STREAM (parser)))
{
- p = skip_spaces_const (PARSER_STREAM (parser));
+ p = skip_spaces (PARSER_STREAM (parser));
/* When we get here we know we've found something followed by
a space (we skip over parens and templates below).
So if we find a keyword now, we know it is a keyword and not,
if (parser->lexer.current.type == LSTOKEN_CONSUMED)
{
/* Skip any whitespace. */
- PARSER_STREAM (parser) = skip_spaces_const (PARSER_STREAM (parser));
+ PARSER_STREAM (parser) = skip_spaces (PARSER_STREAM (parser));
/* Check for a keyword, they end the linespec. */
keyword = linespec_lexer_lex_keyword (PARSER_STREAM (parser));
{
if (*PARSER_STREAM (parser) == ' ')
{
- parser->completion_word = skip_spaces_const (PARSER_STREAM (parser) + 1);
+ parser->completion_word = skip_spaces (PARSER_STREAM (parser) + 1);
parser->complete_what = next;
}
else
if (ptr[i] == ' ')
{
LS_TOKEN_STOKEN (token).length = i;
- PARSER_STREAM (parser) = skip_spaces_const (ptr + i + 1);
+ PARSER_STREAM (parser) = skip_spaces (ptr + i + 1);
break;
}
}
create_sals_line_offset (struct linespec_state *self,
linespec_p ls)
{
- struct symtab_and_line val;
int use_default = 0;
- init_sal (&val);
-
/* This is where we need to make sure we have good defaults.
We must guarantee that this section of code is never executed
when we are called with just a function name, since
use_default = 1;
}
+ symtab_and_line val;
val.line = ls->explicit_loc.line_offset.offset;
switch (ls->explicit_loc.line_offset.sign)
{
else
{
struct linetable_entry *best_entry = NULL;
- int *filter;
- const struct block **blocks;
int i, j;
std::vector<symtab_and_line> intermediate_results
above, we see if there are other PCs that are in the same
block. If yes, the other PCs are filtered out. */
- filter = XNEWVEC (int, intermediate_results.size ());
- struct cleanup *cleanup = make_cleanup (xfree, filter);
- blocks = XNEWVEC (const struct block *, intermediate_results.size ());
- make_cleanup (xfree, blocks);
+ gdb::def_vector<int> filter (intermediate_results.size ());
+ gdb::def_vector<const block *> blocks (intermediate_results.size ());
for (i = 0; i < intermediate_results.size (); ++i)
{
add_sal_to_sals (self, &values, &intermediate_results[i],
sym ? SYMBOL_NATURAL_NAME (sym) : NULL, 0);
}
-
- do_cleanups (cleanup);
}
if (values.empty ())
advances past a keyword automatically, so skip it
manually. */
parser->completion_word
- = skip_spaces_const (skip_to_space_const (PARSER_STREAM (parser)));
+ = skip_spaces (skip_to_space (PARSER_STREAM (parser)));
parser->complete_what = linespec_complete_what::EXPRESSION;
}
/* See description in linespec.h. */
void
-linespec_lex_to_end (char **stringp)
+linespec_lex_to_end (const char **stringp)
{
linespec_parser parser;
struct cleanup *cleanup;
/* See linespec.h. */
std::vector<symtab_and_line>
-decode_line_with_current_source (char *string, int flags)
+decode_line_with_current_source (const char *string, int flags)
{
if (string == 0)
error (_("Empty line specification."));
/* See linespec.h. */
std::vector<symtab_and_line>
-decode_line_with_last_displayed (char *string, int flags)
+decode_line_with_last_displayed (const char *string, int flags)
{
if (string == 0)
error (_("Empty line specification."));
if (self->canonical)
{
- char *str;
+ std::string holder;
+ const char *str;
self->canonical->pre_expanded = 1;
if (ls->explicit_loc.source_filename)
{
- str = xstrprintf ("%s:%s",
- ls->explicit_loc.source_filename, saved_arg);
+ holder = string_printf ("%s:%s",
+ ls->explicit_loc.source_filename,
+ saved_arg);
+ str = holder.c_str ();
}
else
- str = xstrdup (saved_arg);
+ str = saved_arg;
- make_cleanup (xfree, str);
self->canonical->location = new_linespec_location (&str);
}
}
pcs = find_pcs_for_symtab_line (elt, line, best_entry);
for (CORE_ADDR pc : pcs)
{
- struct symtab_and_line sal;
-
- init_sal (&sal);
+ symtab_and_line sal;
sal.pspace = SYMTAB_PSPACE (elt);
sal.symtab = elt;
sal.line = line;
CORE_ADDR pc;
struct symtab_and_line sal;
- sal = find_pc_sect_line (MSYMBOL_VALUE_ADDRESS (objfile, msymbol),
- (struct obj_section *) 0, 0);
- sal.section = MSYMBOL_OBJ_SECTION (objfile, msymbol);
-
- /* The minimal symbol might point to a function descriptor;
- resolve it to the actual code address instead. */
- pc = gdbarch_convert_from_func_ptr_addr (gdbarch, sal.pc, ¤t_target);
- if (pc != sal.pc)
- sal = find_pc_sect_line (pc, NULL, 0);
-
- if (self->funfirstline)
+ if (msymbol_is_text (msymbol))
{
- if (sal.symtab != NULL
- && (COMPUNIT_LOCATIONS_VALID (SYMTAB_COMPUNIT (sal.symtab))
- || SYMTAB_LANGUAGE (sal.symtab) == language_asm))
+ sal = find_pc_sect_line (MSYMBOL_VALUE_ADDRESS (objfile, msymbol),
+ (struct obj_section *) 0, 0);
+ sal.section = MSYMBOL_OBJ_SECTION (objfile, msymbol);
+
+ /* The minimal symbol might point to a function descriptor;
+ resolve it to the actual code address instead. */
+ pc = gdbarch_convert_from_func_ptr_addr (gdbarch, sal.pc,
+ ¤t_target);
+ if (pc != sal.pc)
+ sal = find_pc_sect_line (pc, NULL, 0);
+
+ if (self->funfirstline)
{
- /* If gdbarch_convert_from_func_ptr_addr does not apply then
- sal.SECTION, sal.LINE&co. will stay correct from above.
- If gdbarch_convert_from_func_ptr_addr applies then
- sal.SECTION is cleared from above and sal.LINE&co. will
- stay correct from the last find_pc_sect_line above. */
- sal.pc = MSYMBOL_VALUE_ADDRESS (objfile, msymbol);
- sal.pc = gdbarch_convert_from_func_ptr_addr (gdbarch, sal.pc,
- ¤t_target);
- if (gdbarch_skip_entrypoint_p (gdbarch))
- sal.pc = gdbarch_skip_entrypoint (gdbarch, sal.pc);
+ if (sal.symtab != NULL
+ && (COMPUNIT_LOCATIONS_VALID (SYMTAB_COMPUNIT (sal.symtab))
+ || SYMTAB_LANGUAGE (sal.symtab) == language_asm))
+ {
+ /* If gdbarch_convert_from_func_ptr_addr does not apply then
+ sal.SECTION, sal.LINE&co. will stay correct from above.
+ If gdbarch_convert_from_func_ptr_addr applies then
+ sal.SECTION is cleared from above and sal.LINE&co. will
+ stay correct from the last find_pc_sect_line above. */
+ sal.pc = MSYMBOL_VALUE_ADDRESS (objfile, msymbol);
+ sal.pc = gdbarch_convert_from_func_ptr_addr (gdbarch, sal.pc,
+ ¤t_target);
+ if (gdbarch_skip_entrypoint_p (gdbarch))
+ sal.pc = gdbarch_skip_entrypoint (gdbarch, sal.pc);
+ }
+ else
+ skip_prologue_sal (&sal);
}
- else
- skip_prologue_sal (&sal);
+ }
+ else
+ {
+ sal.objfile = objfile;
+ sal.pc = MSYMBOL_VALUE_ADDRESS (objfile, msymbol);
+ sal.pspace = current_program_space;
+ sal.section = MSYMBOL_OBJ_SECTION (objfile, msymbol);
}
if (maybe_add_address (self->addr_set, objfile->pspace, sal.pc))
{
if (SYMBOL_CLASS (sym) == LOC_LABEL && SYMBOL_VALUE_ADDRESS (sym) != 0)
{
- init_sal (result);
+ *result = {};
result->symtab = symbol_symtab (sym);
+ result->symbol = sym;
result->line = SYMBOL_LINE (sym);
result->pc = SYMBOL_VALUE_ADDRESS (sym);
result->pspace = SYMTAB_PSPACE (result->symtab);
else if (SYMBOL_LINE (sym) != 0)
{
/* We know its line number. */
- init_sal (result);
+ *result = {};
result->symtab = symbol_symtab (sym);
+ result->symbol = sym;
result->line = SYMBOL_LINE (sym);
+ result->pc = SYMBOL_VALUE_ADDRESS (sym);
result->pspace = SYMTAB_PSPACE (result->symtab);
return 1;
}