static void initialize_defaults (struct symtab **default_symtab,
int *default_line);
-static CORE_ADDR linespec_expression_to_pc (const char **exp_ptr);
+CORE_ADDR linespec_expression_to_pc (const char **exp_ptr);
static struct symtabs_and_lines decode_objc (struct linespec_state *self,
linespec_p ls,
canonicalize_linespec (struct linespec_state *state, const linespec_p ls)
{
char *tmp;
+ struct ui_file *buf;
+ int need_colon = 0;
+ struct cleanup *cleanup;
/* If canonicalization was not requested, no need to do anything. */
if (!state->canonical)
return;
- /* Shortcut expressions, which can only appear by themselves. */
- if (ls->expression != NULL)
+ buf = mem_fileopen ();
+ cleanup = make_cleanup_ui_file_delete (buf);
+
+ if (ls->source_filename)
{
- tmp = ASTRDUP (ls->expression);
- state->canonical->location = new_linespec_location (&tmp);
+ fputs_unfiltered (ls->source_filename, buf);
+ need_colon = 1;
}
- else
- {
- struct ui_file *buf;
- int need_colon = 0;
- struct cleanup *cleanup;
- buf = mem_fileopen ();
- cleanup = make_cleanup_ui_file_delete (buf);
+ if (ls->function_name)
+ {
+ if (need_colon)
+ fputc_unfiltered (':', buf);
+ fputs_unfiltered (ls->function_name, buf);
+ need_colon = 1;
+ }
- if (ls->source_filename)
- {
- fputs_unfiltered (ls->source_filename, buf);
- need_colon = 1;
- }
+ if (ls->label_name)
+ {
+ if (need_colon)
+ fputc_unfiltered (':', buf);
- if (ls->function_name)
+ if (ls->function_name == NULL)
{
- if (need_colon)
- fputc_unfiltered (':', buf);
- fputs_unfiltered (ls->function_name, buf);
- need_colon = 1;
+ struct symbol *s;
+
+ /* No function was specified, so add the symbol name. */
+ gdb_assert (ls->labels.function_symbols != NULL
+ && (VEC_length (symbolp, ls->labels.function_symbols)
+ == 1));
+ s = VEC_index (symbolp, ls->labels.function_symbols, 0);
+ fputs_unfiltered (SYMBOL_NATURAL_NAME (s), buf);
+ fputc_unfiltered (':', buf);
}
- if (ls->label_name)
- {
- if (need_colon)
- fputc_unfiltered (':', buf);
-
- if (ls->function_name == NULL)
- {
- struct symbol *s;
-
- /* No function was specified, so add the symbol name. */
- gdb_assert (ls->labels.function_symbols != NULL
- && (VEC_length (symbolp, ls->labels.function_symbols)
- == 1));
- s = VEC_index (symbolp, ls->labels.function_symbols, 0);
- fputs_unfiltered (SYMBOL_NATURAL_NAME (s), buf);
- fputc_unfiltered (':', buf);
- }
-
- fputs_unfiltered (ls->label_name, buf);
- need_colon = 1;
- state->canonical->special_display = 1;
- }
-
- if (ls->line_offset.sign != LINE_OFFSET_UNKNOWN)
- {
- if (need_colon)
- fputc_unfiltered (':', buf);
- fprintf_filtered (buf, "%s%d",
- (ls->line_offset.sign == LINE_OFFSET_NONE ? ""
- : (ls->line_offset.sign
- == LINE_OFFSET_PLUS ? "+" : "-")),
- ls->line_offset.offset);
- }
+ fputs_unfiltered (ls->label_name, buf);
+ need_colon = 1;
+ state->canonical->special_display = 1;
+ }
- tmp = ui_file_xstrdup (buf, NULL);
- make_cleanup (xfree, tmp);
- state->canonical->location = new_linespec_location (&tmp);
- do_cleanups (cleanup);
+ if (ls->line_offset.sign != LINE_OFFSET_UNKNOWN)
+ {
+ if (need_colon)
+ fputc_unfiltered (':', buf);
+ fprintf_filtered (buf, "%s%d",
+ (ls->line_offset.sign == LINE_OFFSET_NONE ? ""
+ : (ls->line_offset.sign
+ == LINE_OFFSET_PLUS ? "+" : "-")),
+ ls->line_offset.offset);
}
+
+ tmp = ui_file_xstrdup (buf, NULL);
+ make_cleanup (xfree, tmp);
+ state->canonical->location = new_linespec_location (&tmp);
+ do_cleanups (cleanup);
}
/* Given a line offset in LS, construct the relevant SALs. */
return values;
}
+/* Convert the given ADDRESS into SaLs. */
+
+static struct symtabs_and_lines
+convert_address_location_to_sals (struct linespec_state *self,
+ CORE_ADDR address)
+{
+ struct symtab_and_line sal;
+ struct symtabs_and_lines sals = {NULL, 0};
+
+ sal = find_pc_line (address, 0);
+ sal.pc = address;
+ sal.section = find_pc_overlay (address);
+ sal.explicit_pc = 1;
+ add_sal_to_sals (self, &sals, &sal, core_addr_to_string (address), 1);
+
+ return sals;
+}
+
/* Create and return SALs from the linespec LS. */
static struct symtabs_and_lines
{
struct symtabs_and_lines sals = {NULL, 0};
- if (ls->expression != NULL)
- {
- struct symtab_and_line sal;
-
- /* We have an expression. No other attribute is allowed. */
- sal = find_pc_line (ls->expr_pc, 0);
- sal.pc = ls->expr_pc;
- sal.section = find_pc_overlay (ls->expr_pc);
- sal.explicit_pc = 1;
- add_sal_to_sals (state, &sals, &sal, ls->expression, 1);
- }
- else if (ls->labels.label_symbols != NULL)
+ if (ls->labels.label_symbols != NULL)
{
/* We have just a bunch of functions/methods or labels. */
int i;
The basic grammar of linespecs:
- linespec -> expr_spec | var_spec | basic_spec
- expr_spec -> '*' STRING
+ linespec -> var_spec | basic_spec
var_spec -> '$' (STRING | NUMBER)
basic_spec -> file_offset_spec | function_spec | label_spec
token = linespec_lexer_lex_one (parser);
/* It must be either LSTOKEN_STRING or LSTOKEN_NUMBER. */
- if (token.type == LSTOKEN_STRING && *LS_TOKEN_STOKEN (token).ptr == '*')
- {
- char *expr;
- const char *copy;
-
- /* User specified an expression, *EXPR. */
- copy = expr = copy_token_string (token);
- cleanup = make_cleanup (xfree, expr);
- PARSER_RESULT (parser)->expr_pc = linespec_expression_to_pc (©);
- discard_cleanups (cleanup);
- PARSER_RESULT (parser)->expression = expr;
-
- /* This is a little hacky/tricky. If linespec_expression_to_pc
- did not evaluate the entire token, then we must find the
- string COPY inside the original token buffer. */
- if (*copy != '\0')
- {
- PARSER_STREAM (parser) = strstr (parser->lexer.saved_arg, copy);
- gdb_assert (PARSER_STREAM (parser) != NULL);
- }
-
- /* Consume the token. */
- linespec_lexer_consume_token (parser);
-
- goto convert_to_sals;
- }
- else if (token.type == LSTOKEN_STRING && *LS_TOKEN_STOKEN (token).ptr == '$')
+ if (token.type == LSTOKEN_STRING && *LS_TOKEN_STOKEN (token).ptr == '$')
{
char *var;
token = linespec_lexer_peek_token (&parser);
if (token.type == LSTOKEN_COMMA)
break;
-
- /* For addresses advance the parser stream past
- any parsed input and stop lexing. */
- if (token.type == LSTOKEN_STRING
- && *LS_TOKEN_STOKEN (token).ptr == '*')
- {
- const char *arg;
-
- arg = *stringp;
- (void) linespec_expression_to_pc (&arg);
- PARSER_STREAM (&parser) = arg;
- break;
- }
-
token = linespec_lexer_consume_token (&parser);
}
while (token.type != LSTOKEN_EOI && token.type != LSTOKEN_KEYWORD);
}
break;
+ case ADDRESS_LOCATION:
+ result
+ = convert_address_location_to_sals (PARSER_STATE (parser),
+ get_address_location (location));
+ break;
+
default:
gdb_assert_not_reached ("unhandled event location type");
}
/* Evaluate the expression pointed to by EXP_PTR into a CORE_ADDR,
advancing EXP_PTR past any parsed text. */
-static CORE_ADDR
+CORE_ADDR
linespec_expression_to_pc (const char **exp_ptr)
{
if (current_program_space->executing_startup)
probes. */
char *addr_string;
#define EL_LINESPEC(PTR) ((PTR)->u.addr_string)
+
+ /* An address in the inferior. */
+ CORE_ADDR address;
+#define EL_ADDRESS(PTR) (PTR)->u.address
} u;
/* Cached string representation of this location. This is used, e.g., to
/* See description in location.h. */
+struct event_location *
+new_address_location (CORE_ADDR addr)
+{
+ struct event_location *location;
+
+ location = XCNEW (struct event_location);
+ EL_TYPE (location) = ADDRESS_LOCATION;
+ EL_ADDRESS (location) = addr;
+ return location;
+}
+
+/* See description in location.h. */
+
+CORE_ADDR
+get_address_location (const struct event_location *location)
+{
+ gdb_assert (EL_TYPE (location) == ADDRESS_LOCATION);
+ return EL_ADDRESS (location);
+}
+
+/* See description in location.h. */
+
struct event_location *
copy_event_location (const struct event_location *src)
{
EL_LINESPEC (dst) = xstrdup (EL_LINESPEC (src));
break;
+ case ADDRESS_LOCATION:
+ EL_ADDRESS (dst) = EL_ADDRESS (src);
+ break;
+
default:
gdb_assert_not_reached ("unknown event location type");
}
xfree (EL_LINESPEC (location));
break;
+ case ADDRESS_LOCATION:
+ /* Nothing to do. */
+ break;
+
default:
gdb_assert_not_reached ("unknown event location type");
}
EL_STRING (location) = xstrdup (EL_LINESPEC (location));
break;
+ case ADDRESS_LOCATION:
+ EL_STRING (location)
+ = xstrprintf ("*%s",
+ core_addr_to_string (EL_ADDRESS (location)));
+ break;
+
default:
gdb_assert_not_reached ("unknown event location type");
}
{
struct event_location *location;
- location = new_linespec_location (stringp);
+ /* First, check if the string is an address location. */
+ if (*stringp != NULL && **stringp == '*')
+ {
+ const char *arg, *orig;
+ CORE_ADDR addr;
+
+ orig = arg = *stringp;
+ addr = linespec_expression_to_pc (&arg);
+ location = new_address_location (addr);
+ *stringp += arg - orig;
+ }
+ else
+ {
+ /* Everything else is a linespec. */
+ location = new_linespec_location (stringp);
+ }
+
return location;
}
/* Linespecs are never "empty." (NULL is a valid linespec) */
return 0;
+ case ADDRESS_LOCATION:
+ return 0;
+
default:
gdb_assert_not_reached ("unknown event location type");
}
projects / deliverable / binutils-gdb.git / commitdiff
