mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-06 00:34:26 +08:00
268a13a5a3
This is the next patch in the ongoing series to move gdbsever to the top level. This patch just renames the "common" directory. The idea is to do this move in two parts: first rename the directory (this patch), then move the directory to the top. This approach makes the patches a bit more tractable. I chose the name "gdbsupport" for the directory. However, as this patch was largely written by sed, we could pick a new name without too much difficulty. Tested by the buildbot. gdb/ChangeLog 2019-07-09 Tom Tromey <tom@tromey.com> * contrib/ari/gdb_ari.sh: Change common to gdbsupport. * configure: Rebuild. * configure.ac: Change common to gdbsupport. * gdbsupport: Rename from common. * acinclude.m4: Change common to gdbsupport. * Makefile.in (CONFIG_SRC_SUBDIR, COMMON_SFILES) (HFILES_NO_SRCDIR, stamp-version, ALLDEPFILES): Change common to gdbsupport. * aarch64-tdep.c, ada-lang.c, ada-lang.h, agent.c, alloc.c, amd64-darwin-tdep.c, amd64-dicos-tdep.c, amd64-fbsd-nat.c, amd64-fbsd-tdep.c, amd64-linux-nat.c, amd64-linux-tdep.c, amd64-nbsd-tdep.c, amd64-obsd-tdep.c, amd64-sol2-tdep.c, amd64-tdep.c, amd64-windows-tdep.c, arch-utils.c, arch/aarch64-insn.c, arch/aarch64.c, arch/aarch64.h, arch/amd64.c, arch/amd64.h, arch/arm-get-next-pcs.c, arch/arm-linux.c, arch/arm.c, arch/i386.c, arch/i386.h, arch/ppc-linux-common.c, arch/riscv.c, arch/riscv.h, arch/tic6x.c, arm-tdep.c, auto-load.c, auxv.c, ax-gdb.c, ax-general.c, ax.h, breakpoint.c, breakpoint.h, btrace.c, btrace.h, build-id.c, build-id.h, c-lang.h, charset.c, charset.h, cli/cli-cmds.c, cli/cli-cmds.h, cli/cli-decode.c, cli/cli-dump.c, cli/cli-option.h, cli/cli-script.c, coff-pe-read.c, command.h, compile/compile-c-support.c, compile/compile-c.h, compile/compile-cplus-symbols.c, compile/compile-cplus-types.c, compile/compile-cplus.h, compile/compile-loc2c.c, compile/compile.c, completer.c, completer.h, contrib/ari/gdb_ari.sh, corefile.c, corelow.c, cp-support.c, cp-support.h, cp-valprint.c, csky-tdep.c, ctf.c, darwin-nat.c, debug.c, defs.h, disasm-selftests.c, disasm.c, disasm.h, dtrace-probe.c, dwarf-index-cache.c, dwarf-index-cache.h, dwarf-index-write.c, dwarf2-frame.c, dwarf2expr.c, dwarf2loc.c, dwarf2read.c, event-loop.c, event-top.c, exceptions.c, exec.c, extension.h, fbsd-nat.c, features/aarch64-core.c, features/aarch64-fpu.c, features/aarch64-pauth.c, features/aarch64-sve.c, features/i386/32bit-avx.c, features/i386/32bit-avx512.c, features/i386/32bit-core.c, features/i386/32bit-linux.c, features/i386/32bit-mpx.c, features/i386/32bit-pkeys.c, features/i386/32bit-segments.c, features/i386/32bit-sse.c, features/i386/64bit-avx.c, features/i386/64bit-avx512.c, features/i386/64bit-core.c, features/i386/64bit-linux.c, features/i386/64bit-mpx.c, features/i386/64bit-pkeys.c, features/i386/64bit-segments.c, features/i386/64bit-sse.c, features/i386/x32-core.c, features/riscv/32bit-cpu.c, features/riscv/32bit-csr.c, features/riscv/32bit-fpu.c, features/riscv/64bit-cpu.c, features/riscv/64bit-csr.c, features/riscv/64bit-fpu.c, features/tic6x-c6xp.c, features/tic6x-core.c, features/tic6x-gp.c, filename-seen-cache.h, findcmd.c, findvar.c, fork-child.c, gcore.c, gdb_bfd.c, gdb_bfd.h, gdb_proc_service.h, gdb_regex.c, gdb_select.h, gdb_usleep.c, gdbarch-selftests.c, gdbthread.h, gdbtypes.h, gnu-nat.c, go32-nat.c, guile/guile.c, guile/scm-ports.c, guile/scm-safe-call.c, guile/scm-type.c, i386-fbsd-nat.c, i386-fbsd-tdep.c, i386-go32-tdep.c, i386-linux-nat.c, i386-linux-tdep.c, i386-tdep.c, i387-tdep.c, ia64-libunwind-tdep.c, ia64-linux-nat.c, inf-child.c, inf-ptrace.c, infcall.c, infcall.h, infcmd.c, inferior-iter.h, inferior.c, inferior.h, inflow.c, inflow.h, infrun.c, infrun.h, inline-frame.c, language.h, linespec.c, linux-fork.c, linux-nat.c, linux-tdep.c, linux-thread-db.c, location.c, machoread.c, macrotab.h, main.c, maint.c, maint.h, memattr.c, memrange.h, mi/mi-cmd-break.h, mi/mi-cmd-env.c, mi/mi-cmd-stack.c, mi/mi-cmd-var.c, mi/mi-interp.c, mi/mi-main.c, mi/mi-parse.h, minsyms.c, mips-linux-tdep.c, namespace.h, nat/aarch64-linux-hw-point.c, nat/aarch64-linux-hw-point.h, nat/aarch64-linux.c, nat/aarch64-sve-linux-ptrace.c, nat/amd64-linux-siginfo.c, nat/fork-inferior.c, nat/linux-btrace.c, nat/linux-btrace.h, nat/linux-namespaces.c, nat/linux-nat.h, nat/linux-osdata.c, nat/linux-personality.c, nat/linux-procfs.c, nat/linux-ptrace.c, nat/linux-ptrace.h, nat/linux-waitpid.c, nat/mips-linux-watch.c, nat/mips-linux-watch.h, nat/ppc-linux.c, nat/x86-dregs.c, nat/x86-dregs.h, nat/x86-linux-dregs.c, nat/x86-linux.c, nto-procfs.c, nto-tdep.c, objfile-flags.h, objfiles.c, objfiles.h, obsd-nat.c, observable.h, osdata.c, p-valprint.c, parse.c, parser-defs.h, ppc-linux-nat.c, printcmd.c, probe.c, proc-api.c, procfs.c, producer.c, progspace.h, psymtab.h, python/py-framefilter.c, python/py-inferior.c, python/py-ref.h, python/py-type.c, python/python.c, record-btrace.c, record-full.c, record.c, record.h, regcache-dump.c, regcache.c, regcache.h, remote-fileio.c, remote-fileio.h, remote-sim.c, remote.c, riscv-tdep.c, rs6000-aix-tdep.c, rust-exp.y, s12z-tdep.c, selftest-arch.c, ser-base.c, ser-event.c, ser-pipe.c, ser-tcp.c, ser-unix.c, skip.c, solib-aix.c, solib-target.c, solib.c, source-cache.c, source.c, source.h, sparc-nat.c, spu-linux-nat.c, stack.c, stap-probe.c, symfile-add-flags.h, symfile.c, symfile.h, symtab.c, symtab.h, target-descriptions.c, target-descriptions.h, target-memory.c, target.c, target.h, target/waitstatus.c, target/waitstatus.h, thread-iter.h, thread.c, tilegx-tdep.c, top.c, top.h, tracefile-tfile.c, tracefile.c, tracepoint.c, tracepoint.h, tui/tui-io.c, ui-file.c, ui-out.h, unittests/array-view-selftests.c, unittests/child-path-selftests.c, unittests/cli-utils-selftests.c, unittests/common-utils-selftests.c, unittests/copy_bitwise-selftests.c, unittests/environ-selftests.c, unittests/format_pieces-selftests.c, unittests/function-view-selftests.c, unittests/lookup_name_info-selftests.c, unittests/memory-map-selftests.c, unittests/memrange-selftests.c, unittests/mkdir-recursive-selftests.c, unittests/observable-selftests.c, unittests/offset-type-selftests.c, unittests/optional-selftests.c, unittests/parse-connection-spec-selftests.c, unittests/ptid-selftests.c, unittests/rsp-low-selftests.c, unittests/scoped_fd-selftests.c, unittests/scoped_mmap-selftests.c, unittests/scoped_restore-selftests.c, unittests/string_view-selftests.c, unittests/style-selftests.c, unittests/tracepoint-selftests.c, unittests/unpack-selftests.c, unittests/utils-selftests.c, unittests/xml-utils-selftests.c, utils.c, utils.h, valarith.c, valops.c, valprint.c, value.c, value.h, varobj.c, varobj.h, windows-nat.c, x86-linux-nat.c, xml-support.c, xml-support.h, xml-tdesc.h, xstormy16-tdep.c, xtensa-linux-nat.c, dwarf2read.h: Change common to gdbsupport. gdb/gdbserver/ChangeLog 2019-07-09 Tom Tromey <tom@tromey.com> * configure: Rebuild. * configure.ac: Change common to gdbsupport. * acinclude.m4: Change common to gdbsupport. * Makefile.in (SFILES, OBS, GDBREPLAY_OBS, IPA_OBJS) (version-generated.c, gdbsupport/%-ipa.o, gdbsupport/%.o): Change common to gdbsupport. * ax.c, event-loop.c, fork-child.c, gdb_proc_service.h, gdbreplay.c, gdbthread.h, hostio-errno.c, hostio.c, i387-fp.c, inferiors.c, inferiors.h, linux-aarch64-tdesc-selftest.c, linux-amd64-ipa.c, linux-i386-ipa.c, linux-low.c, linux-tic6x-low.c, linux-x86-low.c, linux-x86-tdesc-selftest.c, linux-x86-tdesc.c, lynx-i386-low.c, lynx-low.c, mem-break.h, nto-x86-low.c, regcache.c, regcache.h, remote-utils.c, server.c, server.h, spu-low.c, symbol.c, target.h, tdesc.c, tdesc.h, thread-db.c, tracepoint.c, win32-i386-low.c, win32-low.c: Change common to gdbsupport.
987 lines
27 KiB
C
987 lines
27 KiB
C
/* Data structures and API for event locations in GDB.
|
|
Copyright (C) 2013-2019 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 "gdbsupport/gdb_assert.h"
|
|
#include "location.h"
|
|
#include "symtab.h"
|
|
#include "language.h"
|
|
#include "linespec.h"
|
|
#include "cli/cli-utils.h"
|
|
#include "probe.h"
|
|
#include "cp-support.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 probe. */
|
|
char *addr_string;
|
|
#define EL_PROBE(P) ((P)->u.addr_string)
|
|
|
|
/* A "normal" linespec. */
|
|
struct linespec_location linespec_location;
|
|
#define EL_LINESPEC(P) (&(P)->u.linespec_location)
|
|
|
|
/* 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;
|
|
explicit_loc->func_name_match_type = symbol_name_match_type::WILD;
|
|
}
|
|
|
|
/* See description in location.h. */
|
|
|
|
event_location_up
|
|
new_linespec_location (const char **linespec,
|
|
symbol_name_match_type match_type)
|
|
{
|
|
struct event_location *location;
|
|
|
|
location = XCNEW (struct event_location);
|
|
EL_TYPE (location) = LINESPEC_LOCATION;
|
|
EL_LINESPEC (location)->match_type = match_type;
|
|
if (*linespec != NULL)
|
|
{
|
|
const char *p;
|
|
const char *orig = *linespec;
|
|
|
|
linespec_lex_to_end (linespec);
|
|
p = remove_trailing_whitespace (orig, *linespec);
|
|
if ((p - orig) > 0)
|
|
EL_LINESPEC (location)->spec_string = savestring (orig, p - orig);
|
|
}
|
|
return event_location_up (location);
|
|
}
|
|
|
|
/* See description in location.h. */
|
|
|
|
const linespec_location *
|
|
get_linespec_location (const struct event_location *location)
|
|
{
|
|
gdb_assert (EL_TYPE (location) == LINESPEC_LOCATION);
|
|
return EL_LINESPEC (location);
|
|
}
|
|
|
|
/* See description in location.h. */
|
|
|
|
event_location_up
|
|
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 event_location_up (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. */
|
|
|
|
event_location_up
|
|
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 event_location_up (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. */
|
|
|
|
event_location_up
|
|
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)
|
|
{
|
|
EL_EXPLICIT (&tmp)->func_name_match_type
|
|
= explicit_loc->func_name_match_type;
|
|
|
|
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)
|
|
{
|
|
int need_space = 0;
|
|
char space = as_linespec ? ':' : ' ';
|
|
string_file buf;
|
|
|
|
if (explicit_loc->source_filename != NULL)
|
|
{
|
|
if (!as_linespec)
|
|
buf.puts ("-source ");
|
|
buf.puts (explicit_loc->source_filename);
|
|
need_space = 1;
|
|
}
|
|
|
|
if (explicit_loc->function_name != NULL)
|
|
{
|
|
if (need_space)
|
|
buf.putc (space);
|
|
if (explicit_loc->func_name_match_type == symbol_name_match_type::FULL)
|
|
buf.puts ("-qualified ");
|
|
if (!as_linespec)
|
|
buf.puts ("-function ");
|
|
buf.puts (explicit_loc->function_name);
|
|
need_space = 1;
|
|
}
|
|
|
|
if (explicit_loc->label_name != NULL)
|
|
{
|
|
if (need_space)
|
|
buf.putc (space);
|
|
if (!as_linespec)
|
|
buf.puts ("-label ");
|
|
buf.puts (explicit_loc->label_name);
|
|
need_space = 1;
|
|
}
|
|
|
|
if (explicit_loc->line_offset.sign != LINE_OFFSET_UNKNOWN)
|
|
{
|
|
if (need_space)
|
|
buf.putc (space);
|
|
if (!as_linespec)
|
|
buf.puts ("-line ");
|
|
buf.printf ("%s%d",
|
|
(explicit_loc->line_offset.sign == LINE_OFFSET_NONE ? ""
|
|
: (explicit_loc->line_offset.sign
|
|
== LINE_OFFSET_PLUS ? "+" : "-")),
|
|
explicit_loc->line_offset.offset);
|
|
}
|
|
|
|
return xstrdup (buf.c_str ());
|
|
}
|
|
|
|
/* 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. */
|
|
|
|
event_location_up
|
|
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:
|
|
EL_LINESPEC (dst)->match_type = EL_LINESPEC (src)->match_type;
|
|
if (EL_LINESPEC (src)->spec_string != NULL)
|
|
EL_LINESPEC (dst)->spec_string
|
|
= xstrdup (EL_LINESPEC (src)->spec_string);
|
|
break;
|
|
|
|
case ADDRESS_LOCATION:
|
|
EL_ADDRESS (dst) = EL_ADDRESS (src);
|
|
break;
|
|
|
|
case EXPLICIT_LOCATION:
|
|
EL_EXPLICIT (dst)->func_name_match_type
|
|
= EL_EXPLICIT (src)->func_name_match_type;
|
|
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 event_location_up (dst);
|
|
}
|
|
|
|
void
|
|
event_location_deleter::operator() (event_location *location) const
|
|
{
|
|
if (location != NULL)
|
|
{
|
|
xfree (EL_STRING (location));
|
|
|
|
switch (EL_TYPE (location))
|
|
{
|
|
case LINESPEC_LOCATION:
|
|
xfree (EL_LINESPEC (location)->spec_string);
|
|
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)->spec_string != NULL)
|
|
{
|
|
linespec_location *ls = EL_LINESPEC (location);
|
|
if (ls->match_type == symbol_name_match_type::FULL)
|
|
{
|
|
EL_STRING (location)
|
|
= concat ("-qualified ", ls->spec_string, (char *) NULL);
|
|
}
|
|
else
|
|
EL_STRING (location) = xstrdup (ls->spec_string);
|
|
}
|
|
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);
|
|
}
|
|
|
|
/* Find an instance of the quote character C in the string S that is
|
|
outside of all single- and double-quoted strings (i.e., any quoting
|
|
other than C). */
|
|
|
|
static const char *
|
|
find_end_quote (const char *s, char end_quote_char)
|
|
{
|
|
/* zero if we're not in quotes;
|
|
'"' if we're in a double-quoted string;
|
|
'\'' if we're in a single-quoted string. */
|
|
char nested_quote_char = '\0';
|
|
|
|
for (const char *scan = s; *scan != '\0'; scan++)
|
|
{
|
|
if (nested_quote_char != '\0')
|
|
{
|
|
if (*scan == nested_quote_char)
|
|
nested_quote_char = '\0';
|
|
else if (scan[0] == '\\' && *(scan + 1) != '\0')
|
|
scan++;
|
|
}
|
|
else if (*scan == end_quote_char && nested_quote_char == '\0')
|
|
return scan;
|
|
else if (*scan == '"' || *scan == '\'')
|
|
nested_quote_char = *scan;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* 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 gdb::unique_xmalloc_ptr<char>
|
|
explicit_location_lex_one (const char **inp,
|
|
const struct language_defn *language,
|
|
explicit_completion_info *completion_info)
|
|
{
|
|
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))
|
|
{
|
|
if (completion_info != NULL)
|
|
completion_info->quoted_arg_start = start;
|
|
|
|
const char *end = find_end_quote (start + 1, *start);
|
|
|
|
if (end == NULL)
|
|
{
|
|
if (completion_info == NULL)
|
|
error (_("Unmatched quote, %s."), start);
|
|
|
|
end = start + strlen (start);
|
|
*inp = end;
|
|
return gdb::unique_xmalloc_ptr<char> (savestring (start + 1,
|
|
*inp - start - 1));
|
|
}
|
|
|
|
if (completion_info != NULL)
|
|
completion_info->quoted_arg_end = end;
|
|
*inp = end + 1;
|
|
return gdb::unique_xmalloc_ptr<char> (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 gdb::unique_xmalloc_ptr<char> (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
|
|
&& startswith (*inp, CP_OPERATOR_STR))
|
|
(*inp) += CP_OPERATOR_LEN;
|
|
++(*inp);
|
|
}
|
|
}
|
|
|
|
if (*inp - start > 0)
|
|
return gdb::unique_xmalloc_ptr<char> (savestring (start, *inp - start));
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/* Return true if COMMA points past "operator". START is the start of
|
|
the line that COMMAND points to, hence when reading backwards, we
|
|
must not read any character before START. */
|
|
|
|
static bool
|
|
is_cp_operator (const char *start, const char *comma)
|
|
{
|
|
if (comma != NULL
|
|
&& (comma - start) >= CP_OPERATOR_LEN)
|
|
{
|
|
const char *p = comma;
|
|
|
|
while (p > start && isspace (p[-1]))
|
|
p--;
|
|
if (p - start >= CP_OPERATOR_LEN)
|
|
{
|
|
p -= CP_OPERATOR_LEN;
|
|
if (strncmp (p, CP_OPERATOR_STR, CP_OPERATOR_LEN) == 0
|
|
&& (p == start
|
|
|| !(isalnum (p[-1]) || p[-1] == '_')))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/* When scanning the input string looking for the next explicit
|
|
location option/delimiter, we jump to the next option by looking
|
|
for ",", and "-". Such a character can also appear in C++ symbols
|
|
like "operator," and "operator-". So when we find such a
|
|
character, we call this function to check if we found such a
|
|
symbol, meaning we had a false positive for an option string. In
|
|
that case, we keep looking for the next delimiter, until we find
|
|
one that is not a false positive, or we reach end of string. FOUND
|
|
is the character that scanning found (either '-' or ','), and START
|
|
is the start of the line that FOUND points to, hence when reading
|
|
backwards, we must not read any character before START. Returns a
|
|
pointer to the next non-false-positive delimiter character, or NULL
|
|
if none was found. */
|
|
|
|
static const char *
|
|
skip_op_false_positives (const char *start, const char *found)
|
|
{
|
|
while (found != NULL && is_cp_operator (start, found))
|
|
{
|
|
if (found[0] == '-' && found[1] == '-')
|
|
start = found + 2;
|
|
else
|
|
start = found + 1;
|
|
found = find_toplevel_char (start, *found);
|
|
}
|
|
|
|
return found;
|
|
}
|
|
|
|
/* Assuming both FIRST and NEW_TOK point into the same string, return
|
|
the pointer that is closer to the start of the string. If FIRST is
|
|
NULL, returns NEW_TOK. If NEW_TOK is NULL, returns FIRST. */
|
|
|
|
static const char *
|
|
first_of (const char *first, const char *new_tok)
|
|
{
|
|
if (first == NULL)
|
|
return new_tok;
|
|
else if (new_tok != NULL && new_tok < first)
|
|
return new_tok;
|
|
else
|
|
return first;
|
|
}
|
|
|
|
/* A lexer for functions in explicit locations. This function will
|
|
advance INP past a function until the next option, or until end of
|
|
string. Returns a malloc'd copy of the lexed string or NULL if no
|
|
lexing was done. */
|
|
|
|
static gdb::unique_xmalloc_ptr<char>
|
|
explicit_location_lex_one_function (const char **inp,
|
|
const struct language_defn *language,
|
|
explicit_completion_info *completion_info)
|
|
{
|
|
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)))
|
|
{
|
|
if (completion_info != NULL)
|
|
completion_info->quoted_arg_start = start;
|
|
|
|
const char *end = find_toplevel_char (start + 1, quote_char);
|
|
|
|
if (end == NULL)
|
|
{
|
|
if (completion_info == NULL)
|
|
error (_("Unmatched quote, %s."), start);
|
|
|
|
end = start + strlen (start);
|
|
*inp = end;
|
|
char *saved = savestring (start + 1, *inp - start - 1);
|
|
return gdb::unique_xmalloc_ptr<char> (saved);
|
|
}
|
|
|
|
if (completion_info != NULL)
|
|
completion_info->quoted_arg_end = end;
|
|
*inp = end + 1;
|
|
char *saved = savestring (start + 1, *inp - start - 2);
|
|
return gdb::unique_xmalloc_ptr<char> (saved);
|
|
}
|
|
}
|
|
|
|
const char *comma = find_toplevel_char (start, ',');
|
|
|
|
/* If we have "-function -myfunction", or perhaps better example,
|
|
"-function -[BasicClass doIt]" (objc selector), treat
|
|
"-myfunction" as the function name. I.e., skip the first char if
|
|
it is an hyphen. Don't skip the first char always, because we
|
|
may have C++ "operator<", and find_toplevel_char needs to see the
|
|
'o' in that case. */
|
|
const char *hyphen
|
|
= (*start == '-'
|
|
? find_toplevel_char (start + 1, '-')
|
|
: find_toplevel_char (start, '-'));
|
|
|
|
/* Check for C++ "operator," and "operator-". */
|
|
comma = skip_op_false_positives (start, comma);
|
|
hyphen = skip_op_false_positives (start, hyphen);
|
|
|
|
/* Pick the one that appears first. */
|
|
const char *end = first_of (hyphen, comma);
|
|
|
|
/* See if a linespec keyword appears first. */
|
|
const char *s = start;
|
|
const char *ws = find_toplevel_char (start, ' ');
|
|
while (ws != NULL && linespec_lexer_lex_keyword (ws + 1) == NULL)
|
|
{
|
|
s = ws + 1;
|
|
ws = find_toplevel_char (s, ' ');
|
|
}
|
|
if (ws != NULL)
|
|
end = first_of (end, ws + 1);
|
|
|
|
/* If we don't have any terminator, then take the whole string. */
|
|
if (end == NULL)
|
|
end = start + strlen (start);
|
|
|
|
/* Trim whitespace at the end. */
|
|
while (end > start && end[-1] == ' ')
|
|
end--;
|
|
|
|
*inp = end;
|
|
|
|
if (*inp - start > 0)
|
|
return gdb::unique_xmalloc_ptr<char> (savestring (start, *inp - start));
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/* See description in location.h. */
|
|
|
|
event_location_up
|
|
string_to_explicit_location (const char **argp,
|
|
const struct language_defn *language,
|
|
explicit_completion_info *completion_info)
|
|
{
|
|
event_location_up 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);
|
|
|
|
/* Process option/argument pairs. dprintf_command
|
|
requires that processing stop on ','. */
|
|
while ((*argp)[0] != '\0' && (*argp)[0] != ',')
|
|
{
|
|
int len;
|
|
const char *start;
|
|
|
|
/* Clear these on each iteration, since they should be filled
|
|
with info about the last option. */
|
|
if (completion_info != NULL)
|
|
{
|
|
completion_info->quoted_arg_start = NULL;
|
|
completion_info->quoted_arg_end = NULL;
|
|
}
|
|
|
|
/* 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;
|
|
|
|
if (completion_info != NULL)
|
|
completion_info->last_option = start;
|
|
|
|
/* Get the option string. */
|
|
gdb::unique_xmalloc_ptr<char> opt
|
|
= explicit_location_lex_one (argp, language, NULL);
|
|
|
|
/* Use the length of the option to allow abbreviations. */
|
|
len = strlen (opt.get ());
|
|
|
|
/* Get the argument string. */
|
|
*argp = skip_spaces (*argp);
|
|
|
|
/* All options have a required argument. Checking for this
|
|
required argument is deferred until later. */
|
|
gdb::unique_xmalloc_ptr<char> oarg;
|
|
/* True if we have an argument. This is required because we'll
|
|
move from OARG before checking whether we have an
|
|
argument. */
|
|
bool have_oarg = false;
|
|
|
|
/* True if the option needs an argument. */
|
|
bool need_oarg = false;
|
|
|
|
/* Convenience to consistently set both OARG/HAVE_OARG from
|
|
ARG. */
|
|
auto set_oarg = [&] (gdb::unique_xmalloc_ptr<char> arg)
|
|
{
|
|
if (completion_info != NULL)
|
|
{
|
|
/* We do this here because the set of options that take
|
|
arguments matches the set of explicit location
|
|
options. */
|
|
completion_info->saw_explicit_location_option = true;
|
|
}
|
|
oarg = std::move (arg);
|
|
have_oarg = oarg != NULL;
|
|
need_oarg = true;
|
|
};
|
|
|
|
if (strncmp (opt.get (), "-source", len) == 0)
|
|
{
|
|
set_oarg (explicit_location_lex_one (argp, language,
|
|
completion_info));
|
|
EL_EXPLICIT (location)->source_filename = oarg.release ();
|
|
}
|
|
else if (strncmp (opt.get (), "-function", len) == 0)
|
|
{
|
|
set_oarg (explicit_location_lex_one_function (argp, language,
|
|
completion_info));
|
|
EL_EXPLICIT (location)->function_name = oarg.release ();
|
|
}
|
|
else if (strncmp (opt.get (), "-qualified", len) == 0)
|
|
{
|
|
EL_EXPLICIT (location)->func_name_match_type
|
|
= symbol_name_match_type::FULL;
|
|
}
|
|
else if (strncmp (opt.get (), "-line", len) == 0)
|
|
{
|
|
set_oarg (explicit_location_lex_one (argp, language, NULL));
|
|
*argp = skip_spaces (*argp);
|
|
if (have_oarg)
|
|
{
|
|
EL_EXPLICIT (location)->line_offset
|
|
= linespec_parse_line_offset (oarg.get ());
|
|
continue;
|
|
}
|
|
}
|
|
else if (strncmp (opt.get (), "-label", len) == 0)
|
|
{
|
|
set_oarg (explicit_location_lex_one (argp, language, completion_info));
|
|
EL_EXPLICIT (location)->label_name = oarg.release ();
|
|
}
|
|
/* Only emit an "invalid argument" error for options
|
|
that look like option strings. */
|
|
else if (opt.get ()[0] == '-' && !isdigit (opt.get ()[1]))
|
|
{
|
|
if (completion_info == NULL)
|
|
error (_("invalid explicit location argument, \"%s\""), opt.get ());
|
|
}
|
|
else
|
|
{
|
|
/* End of the explicit location specification.
|
|
Stop parsing and return whatever explicit location was
|
|
parsed. */
|
|
*argp = start;
|
|
break;
|
|
}
|
|
|
|
*argp = skip_spaces (*argp);
|
|
|
|
/* 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 (need_oarg && !have_oarg && completion_info == NULL)
|
|
error (_("missing argument for \"%s\""), opt.get ());
|
|
}
|
|
|
|
/* 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)
|
|
&& completion_info == NULL)
|
|
{
|
|
error (_("Source filename requires function, label, or "
|
|
"line offset."));
|
|
}
|
|
|
|
return location;
|
|
}
|
|
|
|
/* See description in location.h. */
|
|
|
|
event_location_up
|
|
string_to_event_location_basic (const char **stringp,
|
|
const struct language_defn *language,
|
|
symbol_name_match_type match_type)
|
|
{
|
|
event_location_up location;
|
|
const char *cs;
|
|
|
|
/* Try the input as a probe spec. */
|
|
cs = *stringp;
|
|
if (cs != NULL && probe_linespec_to_static_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, match_type);
|
|
}
|
|
}
|
|
|
|
return location;
|
|
}
|
|
|
|
/* See description in location.h. */
|
|
|
|
event_location_up
|
|
string_to_event_location (const char **stringp,
|
|
const struct language_defn *language,
|
|
symbol_name_match_type match_type)
|
|
{
|
|
const char *arg, *orig;
|
|
|
|
/* Try an explicit location. */
|
|
orig = arg = *stringp;
|
|
event_location_up location = string_to_explicit_location (&arg, language, NULL);
|
|
if (location != NULL)
|
|
{
|
|
/* It was a valid explicit location. Advance STRINGP to
|
|
the end of input. */
|
|
*stringp += arg - orig;
|
|
|
|
/* If the user really specified a location, then we're done. */
|
|
if (!event_location_empty_p (location.get ()))
|
|
return location;
|
|
|
|
/* Otherwise, the user _only_ specified optional flags like
|
|
"-qualified", otherwise string_to_explicit_location would
|
|
have thrown an error. Save the flags for "basic" linespec
|
|
parsing below and discard the explicit location. */
|
|
match_type = EL_EXPLICIT (location)->func_name_match_type;
|
|
}
|
|
|
|
/* Everything else is a "basic" linespec, address, or probe
|
|
location. */
|
|
return string_to_event_location_basic (stringp, language, match_type);
|
|
}
|
|
|
|
/* 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);
|
|
}
|