X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Flocation.h;h=8b19f34ad4471f65d382add3a29d5a991639f904;hb=173981bc49c9e8fce9271cb47714952dbe2ec627;hp=d35fecbf08c2e1082a232344541146f236105c93;hpb=c7c1b3e998a77eb077ac3c08c88a97d2e11dfef0;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/location.h b/gdb/location.h index d35fecbf08..8b19f34ad4 100644 --- a/gdb/location.h +++ b/gdb/location.h @@ -1,5 +1,5 @@ /* Data structures and API for event locations in GDB. - Copyright (C) 2013-2015 Free Software Foundation, Inc. + Copyright (C) 2013-2016 Free Software Foundation, Inc. This file is part of GDB. @@ -22,13 +22,70 @@ struct language_defn; struct event_location; +/* An enumeration of possible signs for a line offset. */ + +enum offset_relative_sign +{ + /* No sign */ + LINE_OFFSET_NONE, + + /* A plus sign ("+") */ + LINE_OFFSET_PLUS, + + /* A minus sign ("-") */ + LINE_OFFSET_MINUS, + + /* A special "sign" for unspecified offset. */ + LINE_OFFSET_UNKNOWN +}; + +/* A line offset in a location. */ + +struct line_offset +{ + /* Line offset and any specified sign. */ + int offset; + enum offset_relative_sign sign; +}; + /* An enumeration of the various ways to specify a stop event location (used with create_breakpoint). */ enum event_location_type { /* A traditional linespec. */ - LINESPEC_LOCATION + LINESPEC_LOCATION, + + /* An address in the inferior. */ + ADDRESS_LOCATION, + + /* An explicit location. */ + EXPLICIT_LOCATION, + + /* A probe location. */ + PROBE_LOCATION +}; + +/* An explicit location. This structure is used to bypass the + parsing done on linespecs. It still has the same requirements + as linespecs, though. For example, source_filename requires + at least one other field. */ + +struct explicit_location +{ + /* The source filename. Malloc'd. */ + char *source_filename; + + /* The function name. Malloc'd. */ + char *function_name; + + /* The name of a label. Malloc'd. */ + char *label_name; + + /* A line offset relative to the start of the symbol + identified by the above fields or the current symtab + if the other fields are NULL. */ + struct line_offset line_offset; }; /* Return the type of the given event location. */ @@ -36,6 +93,18 @@ enum event_location_type extern enum event_location_type event_location_type (const struct event_location *); +/* Return a malloc'd explicit string representation of the given + explicit location. The location must already be canonicalized/valid. */ + +extern char * + explicit_location_to_string (const struct explicit_location *explicit_loc); + +/* Return a malloc'd linespec string representation of the given + explicit location. The location must already be canonicalized/valid. */ + +extern char * + explicit_location_to_linespec (const struct explicit_location *explicit_loc); + /* Return a string representation of the LOCATION. This function may return NULL for unspecified linespecs, e.g, LOCATION_LINESPEC and addr_string is NULL. @@ -57,6 +126,64 @@ extern struct event_location * extern const char * get_linespec_location (const struct event_location *location); +/* Create a new address location. + ADDR is the address corresponding to this event_location. + ADDR_STRING, a string of ADDR_STRING_LEN characters, is + the expression that was parsed to determine the address ADDR. */ + +extern struct event_location * + new_address_location (CORE_ADDR addr, const char *addr_string, + int addr_string_len); + +/* Return the address location (a CORE_ADDR) of the given event_location + (which must be of type ADDRESS_LOCATION). */ + +extern CORE_ADDR + get_address_location (const struct event_location *location); + +/* Return the expression (a string) that was used to compute the address + of the given event_location (which must be of type ADDRESS_LOCATION). */ + +extern const char * + get_address_string_location (const struct event_location *location); + +/* Create a new probe location. The return result is malloc'd + and should be freed with delete_event_location. */ + +extern struct event_location * + new_probe_location (const char *probe); + +/* Return the probe location (a string) of the given event_location + (which must be of type PROBE_LOCATION). */ + +extern const char * + get_probe_location (const struct event_location *location); + +/* Initialize the given explicit location. */ + +extern void + initialize_explicit_location (struct explicit_location *explicit_loc); + +/* Create a new explicit location. If not NULL, EXPLICIT is checked for + validity. If invalid, an exception is thrown. + + The return result is malloc'd and should be freed with + delete_event_location. */ + +extern struct event_location * + new_explicit_location (const struct explicit_location *explicit_loc); + +/* Return the explicit location of the given event_location + (which must be of type EXPLICIT_LOCATION). */ + +extern struct explicit_location * + get_explicit_location (struct event_location *location); + +/* A const version of the above. */ + +extern const struct explicit_location * + get_explicit_location_const (const struct event_location *location); + /* Free an event location and any associated data. */ extern void delete_event_location (struct event_location *location); @@ -80,12 +207,39 @@ extern struct event_location * but invalid, input, e.g., if it is called with missing argument parameters or invalid options. - The return result must be freed with delete_event_location. */ + The return result must be freed with delete_event_location. + + This function is intended to be used by CLI commands and will parse + explicit locations in a CLI-centric way. Other interfaces should use + string_to_event_location_basic if they want to maintain support for + legacy specifications of probe, address, and linespec locations. */ extern struct event_location * string_to_event_location (char **argp, const struct language_defn *langauge); +/* Like string_to_event_location, but does not attempt to parse explicit + locations. */ + +extern struct event_location * + string_to_event_location_basic (char **argp, + const struct language_defn *language); + +/* Attempt to convert the input string in *ARGP into an explicit location. + ARGP is advanced past any processed input. Returns an event_location + (malloc'd) if an explicit location was successfully found in *ARGP, + NULL otherwise. + + IF !DONT_THROW, this function may call error() if *ARGP looks like + properly formed input, e.g., if it is called with missing argument + parameters or invalid options. If DONT_THROW is non-zero, this function + will not throw any exceptions. */ + +extern struct event_location * + string_to_explicit_location (const char **argp, + const struct language_defn *langauge, + int dont_throw); + /* A convenience function for testing for unset locations. */ extern int event_location_empty_p (const struct event_location *location);