binutils-gdb/gdb/location.c
Joel Brobecker 61baf725ec update copyright year range in GDB files
This applies the second part of GDB's End of Year Procedure, which
updates the copyright year range in all of GDB's files.

gdb/ChangeLog:

        Update copyright year range in all GDB files.
2017-01-01 10:52:34 +04:00

741 lines
19 KiB
C

/* Data structures and API for event locations in GDB.
Copyright (C) 2013-2017 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "gdb_assert.h"
#include "location.h"
#include "symtab.h"
#include "language.h"
#include "linespec.h"
#include "cli/cli-utils.h"
#include "probe.h"
#include <ctype.h>
#include <string.h>
/* An event location used to set a stop event in the inferior.
This structure is an amalgam of the various ways
to specify where a stop event should be set. */
struct event_location
{
/* The type of this breakpoint specification. */
enum event_location_type type;
#define EL_TYPE(P) (P)->type
union
{
/* A generic "this is a string specification" for a location.
This representation is used by both "normal" linespecs and
probes. */
char *addr_string;
#define EL_LINESPEC(P) ((P)->u.addr_string)
#define EL_PROBE(P) ((P)->u.addr_string)
/* An address in the inferior. */
CORE_ADDR address;
#define EL_ADDRESS(P) (P)->u.address
/* An explicit location. */
struct explicit_location explicit_loc;
#define EL_EXPLICIT(P) (&((P)->u.explicit_loc))
} u;
/* Cached string representation of this location. This is used, e.g., to
save stop event locations to file. Malloc'd. */
char *as_string;
#define EL_STRING(P) ((P)->as_string)
};
/* See description in location.h. */
enum event_location_type
event_location_type (const struct event_location *location)
{
return EL_TYPE (location);
}
/* See description in location.h. */
void
initialize_explicit_location (struct explicit_location *explicit_loc)
{
memset (explicit_loc, 0, sizeof (struct explicit_location));
explicit_loc->line_offset.sign = LINE_OFFSET_UNKNOWN;
}
/* See description in location.h. */
struct event_location *
new_linespec_location (char **linespec)
{
struct event_location *location;
location = XCNEW (struct event_location);
EL_TYPE (location) = LINESPEC_LOCATION;
if (*linespec != NULL)
{
char *p;
char *orig = *linespec;
linespec_lex_to_end (linespec);
p = remove_trailing_whitespace (orig, *linespec);
if ((p - orig) > 0)
EL_LINESPEC (location) = savestring (orig, p - orig);
}
return location;
}
/* See description in location.h. */
const char *
get_linespec_location (const struct event_location *location)
{
gdb_assert (EL_TYPE (location) == LINESPEC_LOCATION);
return EL_LINESPEC (location);
}
/* See description in location.h. */
struct event_location *
new_address_location (CORE_ADDR addr, const char *addr_string,
int addr_string_len)
{
struct event_location *location;
location = XCNEW (struct event_location);
EL_TYPE (location) = ADDRESS_LOCATION;
EL_ADDRESS (location) = addr;
if (addr_string != NULL)
EL_STRING (location) = xstrndup (addr_string, addr_string_len);
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. */
const char *
get_address_string_location (const struct event_location *location)
{
gdb_assert (EL_TYPE (location) == ADDRESS_LOCATION);
return EL_STRING (location);
}
/* See description in location.h. */
struct event_location *
new_probe_location (const char *probe)
{
struct event_location *location;
location = XCNEW (struct event_location);
EL_TYPE (location) = PROBE_LOCATION;
if (probe != NULL)
EL_PROBE (location) = xstrdup (probe);
return location;
}
/* See description in location.h. */
const char *
get_probe_location (const struct event_location *location)
{
gdb_assert (EL_TYPE (location) == PROBE_LOCATION);
return EL_PROBE (location);
}
/* See description in location.h. */
struct event_location *
new_explicit_location (const struct explicit_location *explicit_loc)
{
struct event_location tmp;
memset (&tmp, 0, sizeof (struct event_location));
EL_TYPE (&tmp) = EXPLICIT_LOCATION;
initialize_explicit_location (EL_EXPLICIT (&tmp));
if (explicit_loc != NULL)
{
if (explicit_loc->source_filename != NULL)
{
EL_EXPLICIT (&tmp)->source_filename
= explicit_loc->source_filename;
}
if (explicit_loc->function_name != NULL)
EL_EXPLICIT (&tmp)->function_name
= explicit_loc->function_name;
if (explicit_loc->label_name != NULL)
EL_EXPLICIT (&tmp)->label_name = explicit_loc->label_name;
if (explicit_loc->line_offset.sign != LINE_OFFSET_UNKNOWN)
EL_EXPLICIT (&tmp)->line_offset = explicit_loc->line_offset;
}
return copy_event_location (&tmp);
}
/* See description in location.h. */
struct explicit_location *
get_explicit_location (struct event_location *location)
{
gdb_assert (EL_TYPE (location) == EXPLICIT_LOCATION);
return EL_EXPLICIT (location);
}
/* See description in location.h. */
const struct explicit_location *
get_explicit_location_const (const struct event_location *location)
{
gdb_assert (EL_TYPE (location) == EXPLICIT_LOCATION);
return EL_EXPLICIT (location);
}
/* This convenience function returns a malloc'd string which
represents the location in EXPLICIT_LOC.
AS_LINESPEC is non-zero if this string should be a linespec.
Otherwise it will be output in explicit form. */
static char *
explicit_to_string_internal (int as_linespec,
const struct explicit_location *explicit_loc)
{
struct ui_file *buf;
char space, *result;
int need_space = 0;
struct cleanup *cleanup;
space = as_linespec ? ':' : ' ';
buf = mem_fileopen ();
cleanup = make_cleanup_ui_file_delete (buf);
if (explicit_loc->source_filename != NULL)
{
if (!as_linespec)
fputs_unfiltered ("-source ", buf);
fputs_unfiltered (explicit_loc->source_filename, buf);
need_space = 1;
}
if (explicit_loc->function_name != NULL)
{
if (need_space)
fputc_unfiltered (space, buf);
if (!as_linespec)
fputs_unfiltered ("-function ", buf);
fputs_unfiltered (explicit_loc->function_name, buf);
need_space = 1;
}
if (explicit_loc->label_name != NULL)
{
if (need_space)
fputc_unfiltered (space, buf);
if (!as_linespec)
fputs_unfiltered ("-label ", buf);
fputs_unfiltered (explicit_loc->label_name, buf);
need_space = 1;
}
if (explicit_loc->line_offset.sign != LINE_OFFSET_UNKNOWN)
{
if (need_space)
fputc_unfiltered (space, buf);
if (!as_linespec)
fputs_unfiltered ("-line ", buf);
fprintf_filtered (buf, "%s%d",
(explicit_loc->line_offset.sign == LINE_OFFSET_NONE ? ""
: (explicit_loc->line_offset.sign
== LINE_OFFSET_PLUS ? "+" : "-")),
explicit_loc->line_offset.offset);
}
result = ui_file_xstrdup (buf, NULL);
do_cleanups (cleanup);
return result;
}
/* See description in location.h. */
char *
explicit_location_to_string (const struct explicit_location *explicit_loc)
{
return explicit_to_string_internal (0, explicit_loc);
}
/* See description in location.h. */
char *
explicit_location_to_linespec (const struct explicit_location *explicit_loc)
{
return explicit_to_string_internal (1, explicit_loc);
}
/* See description in location.h. */
struct event_location *
copy_event_location (const struct event_location *src)
{
struct event_location *dst;
dst = XCNEW (struct event_location);
EL_TYPE (dst) = EL_TYPE (src);
if (EL_STRING (src) != NULL)
EL_STRING (dst) = xstrdup (EL_STRING (src));
switch (EL_TYPE (src))
{
case LINESPEC_LOCATION:
if (EL_LINESPEC (src) != NULL)
EL_LINESPEC (dst) = xstrdup (EL_LINESPEC (src));
break;
case ADDRESS_LOCATION:
EL_ADDRESS (dst) = EL_ADDRESS (src);
break;
case EXPLICIT_LOCATION:
if (EL_EXPLICIT (src)->source_filename != NULL)
EL_EXPLICIT (dst)->source_filename
= xstrdup (EL_EXPLICIT (src)->source_filename);
if (EL_EXPLICIT (src)->function_name != NULL)
EL_EXPLICIT (dst)->function_name
= xstrdup (EL_EXPLICIT (src)->function_name);
if (EL_EXPLICIT (src)->label_name != NULL)
EL_EXPLICIT (dst)->label_name = xstrdup (EL_EXPLICIT (src)->label_name);
EL_EXPLICIT (dst)->line_offset = EL_EXPLICIT (src)->line_offset;
break;
case PROBE_LOCATION:
if (EL_PROBE (src) != NULL)
EL_PROBE (dst) = xstrdup (EL_PROBE (src));
break;
default:
gdb_assert_not_reached ("unknown event location type");
}
return dst;
}
/* A cleanup function for struct event_location. */
static void
delete_event_location_cleanup (void *data)
{
struct event_location *location = (struct event_location *) data;
delete_event_location (location);
}
/* See description in location.h. */
struct cleanup *
make_cleanup_delete_event_location (struct event_location *location)
{
return make_cleanup (delete_event_location_cleanup, location);
}
/* See description in location.h. */
void
delete_event_location (struct event_location *location)
{
if (location != NULL)
{
xfree (EL_STRING (location));
switch (EL_TYPE (location))
{
case LINESPEC_LOCATION:
xfree (EL_LINESPEC (location));
break;
case ADDRESS_LOCATION:
/* Nothing to do. */
break;
case EXPLICIT_LOCATION:
xfree (EL_EXPLICIT (location)->source_filename);
xfree (EL_EXPLICIT (location)->function_name);
xfree (EL_EXPLICIT (location)->label_name);
break;
case PROBE_LOCATION:
xfree (EL_PROBE (location));
break;
default:
gdb_assert_not_reached ("unknown event location type");
}
xfree (location);
}
}
/* See description in location.h. */
const char *
event_location_to_string (struct event_location *location)
{
if (EL_STRING (location) == NULL)
{
switch (EL_TYPE (location))
{
case LINESPEC_LOCATION:
if (EL_LINESPEC (location) != NULL)
EL_STRING (location) = xstrdup (EL_LINESPEC (location));
break;
case ADDRESS_LOCATION:
EL_STRING (location)
= xstrprintf ("*%s",
core_addr_to_string (EL_ADDRESS (location)));
break;
case EXPLICIT_LOCATION:
EL_STRING (location)
= explicit_location_to_string (EL_EXPLICIT (location));
break;
case PROBE_LOCATION:
EL_STRING (location) = xstrdup (EL_PROBE (location));
break;
default:
gdb_assert_not_reached ("unknown event location type");
}
}
return EL_STRING (location);
}
/* A lexer for explicit locations. This function will advance INP
past any strings that it lexes. Returns a malloc'd copy of the
lexed string or NULL if no lexing was done. */
static char *
explicit_location_lex_one (const char **inp,
const struct language_defn *language)
{
const char *start = *inp;
if (*start == '\0')
return NULL;
/* If quoted, skip to the ending quote. */
if (strchr (get_gdb_linespec_parser_quote_characters (), *start))
{
char quote_char = *start;
/* If the input is not an Ada operator, skip to the matching
closing quote and return the string. */
if (!(language->la_language == language_ada
&& quote_char == '\"' && is_ada_operator (start)))
{
const char *end = find_toplevel_char (start + 1, quote_char);
if (end == NULL)
error (_("Unmatched quote, %s."), start);
*inp = end + 1;
return savestring (start + 1, *inp - start - 2);
}
}
/* If the input starts with '-' or '+', the string ends with the next
whitespace or comma. */
if (*start == '-' || *start == '+')
{
while (*inp[0] != '\0' && *inp[0] != ',' && !isspace (*inp[0]))
++(*inp);
}
else
{
/* Handle numbers first, stopping at the next whitespace or ','. */
while (isdigit (*inp[0]))
++(*inp);
if (*inp[0] == '\0' || isspace (*inp[0]) || *inp[0] == ',')
return savestring (start, *inp - start);
/* Otherwise stop at the next occurrence of whitespace, '\0',
keyword, or ','. */
*inp = start;
while ((*inp)[0]
&& (*inp)[0] != ','
&& !(isspace ((*inp)[0])
|| linespec_lexer_lex_keyword (&(*inp)[1])))
{
/* Special case: C++ operator,. */
if (language->la_language == language_cplus
&& strncmp (*inp, "operator", 8) == 0)
(*inp) += 8;
++(*inp);
}
}
if (*inp - start > 0)
return savestring (start, *inp - start);
return NULL;
}
/* See description in location.h. */
struct event_location *
string_to_explicit_location (const char **argp,
const struct language_defn *language,
int dont_throw)
{
struct cleanup *cleanup;
struct event_location *location;
/* It is assumed that input beginning with '-' and a non-digit
character is an explicit location. "-p" is reserved, though,
for probe locations. */
if (argp == NULL
|| *argp == NULL
|| *argp[0] != '-'
|| !isalpha ((*argp)[1])
|| ((*argp)[0] == '-' && (*argp)[1] == 'p'))
return NULL;
location = new_explicit_location (NULL);
cleanup = make_cleanup_delete_event_location (location);
/* Process option/argument pairs. dprintf_command
requires that processing stop on ','. */
while ((*argp)[0] != '\0' && (*argp)[0] != ',')
{
int len;
char *opt, *oarg;
const char *start;
struct cleanup *opt_cleanup, *oarg_cleanup;
/* If *ARGP starts with a keyword, stop processing
options. */
if (linespec_lexer_lex_keyword (*argp) != NULL)
break;
/* Mark the start of the string in case we need to rewind. */
start = *argp;
/* Get the option string. */
opt = explicit_location_lex_one (argp, language);
opt_cleanup = make_cleanup (xfree, opt);
*argp = skip_spaces_const (*argp);
/* Get the argument string. */
oarg = explicit_location_lex_one (argp, language);
oarg_cleanup = make_cleanup (xfree, oarg);
*argp = skip_spaces_const (*argp);
/* Use the length of the option to allow abbreviations. */
len = strlen (opt);
/* All options have a required argument. Checking for this required
argument is deferred until later. */
if (strncmp (opt, "-source", len) == 0)
EL_EXPLICIT (location)->source_filename = oarg;
else if (strncmp (opt, "-function", len) == 0)
EL_EXPLICIT (location)->function_name = oarg;
else if (strncmp (opt, "-line", len) == 0)
{
if (oarg != NULL)
{
EL_EXPLICIT (location)->line_offset
= linespec_parse_line_offset (oarg);
do_cleanups (oarg_cleanup);
do_cleanups (opt_cleanup);
continue;
}
}
else if (strncmp (opt, "-label", len) == 0)
EL_EXPLICIT (location)->label_name = oarg;
/* Only emit an "invalid argument" error for options
that look like option strings. */
else if (opt[0] == '-' && !isdigit (opt[1]))
{
if (!dont_throw)
error (_("invalid explicit location argument, \"%s\""), opt);
}
else
{
/* End of the explicit location specification.
Stop parsing and return whatever explicit location was
parsed. */
*argp = start;
discard_cleanups (oarg_cleanup);
do_cleanups (opt_cleanup);
discard_cleanups (cleanup);
return location;
}
/* It's a little lame to error after the fact, but in this
case, it provides a much better user experience to issue
the "invalid argument" error before any missing
argument error. */
if (oarg == NULL && !dont_throw)
error (_("missing argument for \"%s\""), opt);
/* The option/argument pair was successfully processed;
oarg belongs to the explicit location, and opt should
be freed. */
discard_cleanups (oarg_cleanup);
do_cleanups (opt_cleanup);
}
/* One special error check: If a source filename was given
without offset, function, or label, issue an error. */
if (EL_EXPLICIT (location)->source_filename != NULL
&& EL_EXPLICIT (location)->function_name == NULL
&& EL_EXPLICIT (location)->label_name == NULL
&& (EL_EXPLICIT (location)->line_offset.sign == LINE_OFFSET_UNKNOWN)
&& !dont_throw)
{
error (_("Source filename requires function, label, or "
"line offset."));
}
discard_cleanups (cleanup);
return location;
}
/* See description in location.h. */
struct event_location *
string_to_event_location_basic (char **stringp,
const struct language_defn *language)
{
struct event_location *location;
const char *cs;
/* Try the input as a probe spec. */
cs = *stringp;
if (cs != NULL && probe_linespec_to_ops (&cs) != NULL)
{
location = new_probe_location (*stringp);
*stringp += strlen (*stringp);
}
else
{
/* Try 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, orig, arg - orig);
*stringp += arg - orig;
}
else
{
/* Everything else is a linespec. */
location = new_linespec_location (stringp);
}
}
return location;
}
/* See description in location.h. */
struct event_location *
string_to_event_location (char **stringp,
const struct language_defn *language)
{
struct event_location *location;
const char *arg, *orig;
/* Try an explicit location. */
orig = arg = *stringp;
location = string_to_explicit_location (&arg, language, 0);
if (location != NULL)
{
/* It was a valid explicit location. Advance STRINGP to
the end of input. */
*stringp += arg - orig;
}
else
{
/* Everything else is a "basic" linespec, address, or probe
location. */
location = string_to_event_location_basic (stringp, language);
}
return location;
}
/* See description in location.h. */
int
event_location_empty_p (const struct event_location *location)
{
switch (EL_TYPE (location))
{
case LINESPEC_LOCATION:
/* Linespecs are never "empty." (NULL is a valid linespec) */
return 0;
case ADDRESS_LOCATION:
return 0;
case EXPLICIT_LOCATION:
return (EL_EXPLICIT (location) == NULL
|| (EL_EXPLICIT (location)->source_filename == NULL
&& EL_EXPLICIT (location)->function_name == NULL
&& EL_EXPLICIT (location)->label_name == NULL
&& (EL_EXPLICIT (location)->line_offset.sign
== LINE_OFFSET_UNKNOWN)));
case PROBE_LOCATION:
return EL_PROBE (location) == NULL;
default:
gdb_assert_not_reached ("unknown event location type");
}
}
/* See description in location.h. */
void
set_event_location_string (struct event_location *location,
const char *string)
{
xfree (EL_STRING (location));
EL_STRING (location) = string == NULL ? NULL : xstrdup (string);
}