2015-02-17 16:03:22 +01:00
|
|
|
/* DTrace probe support for GDB.
|
|
|
|
|
2017-01-01 07:50:51 +01:00
|
|
|
Copyright (C) 2014-2017 Free Software Foundation, Inc.
|
2015-02-17 16:03:22 +01:00
|
|
|
|
|
|
|
Contributed by Oracle, 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 "probe.h"
|
|
|
|
#include "vec.h"
|
|
|
|
#include "elf-bfd.h"
|
|
|
|
#include "gdbtypes.h"
|
|
|
|
#include "obstack.h"
|
|
|
|
#include "objfiles.h"
|
|
|
|
#include "complaints.h"
|
|
|
|
#include "value.h"
|
|
|
|
#include "ax.h"
|
|
|
|
#include "ax-gdb.h"
|
|
|
|
#include "language.h"
|
|
|
|
#include "parser-defs.h"
|
|
|
|
#include "inferior.h"
|
|
|
|
|
|
|
|
/* The type of the ELF sections where we will find the DOF programs
|
|
|
|
with information about probes. */
|
|
|
|
|
|
|
|
#ifndef SHT_SUNW_dof
|
|
|
|
# define SHT_SUNW_dof 0x6ffffff4
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Forward declaration. */
|
|
|
|
|
2015-02-26 15:03:47 +01:00
|
|
|
extern const struct probe_ops dtrace_probe_ops;
|
2015-02-17 16:03:22 +01:00
|
|
|
|
|
|
|
/* The following structure represents a single argument for the
|
|
|
|
probe. */
|
|
|
|
|
|
|
|
struct dtrace_probe_arg
|
|
|
|
{
|
|
|
|
/* The type of the probe argument. */
|
|
|
|
struct type *type;
|
|
|
|
|
|
|
|
/* A string describing the type. */
|
|
|
|
char *type_str;
|
|
|
|
|
|
|
|
/* The argument converted to an internal GDB expression. */
|
|
|
|
struct expression *expr;
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef struct dtrace_probe_arg dtrace_probe_arg_s;
|
|
|
|
DEF_VEC_O (dtrace_probe_arg_s);
|
|
|
|
|
|
|
|
/* The following structure represents an enabler for a probe. */
|
|
|
|
|
|
|
|
struct dtrace_probe_enabler
|
|
|
|
{
|
|
|
|
/* Program counter where the is-enabled probe is installed. The
|
|
|
|
contents (nops, whatever...) stored at this address are
|
|
|
|
architecture dependent. */
|
|
|
|
CORE_ADDR address;
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef struct dtrace_probe_enabler dtrace_probe_enabler_s;
|
|
|
|
DEF_VEC_O (dtrace_probe_enabler_s);
|
|
|
|
|
|
|
|
/* The following structure represents a dtrace probe. */
|
|
|
|
|
|
|
|
struct dtrace_probe
|
|
|
|
{
|
|
|
|
/* Generic information about the probe. This must be the first
|
|
|
|
element of this struct, in order to maintain binary compatibility
|
|
|
|
with the `struct probe' and be able to fully abstract it. */
|
|
|
|
struct probe p;
|
|
|
|
|
|
|
|
/* A probe can have zero or more arguments. */
|
|
|
|
int probe_argc;
|
|
|
|
VEC (dtrace_probe_arg_s) *args;
|
|
|
|
|
|
|
|
/* A probe can have zero or more "enablers" associated with it. */
|
|
|
|
VEC (dtrace_probe_enabler_s) *enablers;
|
|
|
|
|
|
|
|
/* Whether the expressions for the arguments have been built. */
|
|
|
|
unsigned int args_expr_built : 1;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Implementation of the probe_is_linespec method. */
|
|
|
|
|
|
|
|
static int
|
|
|
|
dtrace_probe_is_linespec (const char **linespecp)
|
|
|
|
{
|
|
|
|
static const char *const keywords[] = { "-pdtrace", "-probe-dtrace", NULL };
|
|
|
|
|
|
|
|
return probe_is_linespec_by_keyword (linespecp, keywords);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* DOF programs can contain an arbitrary number of sections of 26
|
|
|
|
different types. In order to support DTrace USDT probes we only
|
|
|
|
need to handle a subset of these section types, fortunately. These
|
|
|
|
section types are defined in the following enumeration.
|
|
|
|
|
|
|
|
See linux/dtrace/dof_defines.h for a complete list of section types
|
|
|
|
along with their values. */
|
|
|
|
|
|
|
|
enum dtrace_dof_sect_type
|
|
|
|
{
|
|
|
|
/* Null section. */
|
|
|
|
DTRACE_DOF_SECT_TYPE_NONE = 0,
|
|
|
|
/* A dof_ecbdesc_t. */
|
|
|
|
DTRACE_DOF_SECT_TYPE_ECBDESC = 3,
|
|
|
|
/* A string table. */
|
|
|
|
DTRACE_DOF_SECT_TYPE_STRTAB = 8,
|
|
|
|
/* A dof_provider_t */
|
|
|
|
DTRACE_DOF_SECT_TYPE_PROVIDER = 15,
|
|
|
|
/* Array of dof_probe_t */
|
|
|
|
DTRACE_DOF_SECT_TYPE_PROBES = 16,
|
|
|
|
/* An array of probe arg mappings. */
|
|
|
|
DTRACE_DOF_SECT_TYPE_PRARGS = 17,
|
|
|
|
/* An array of probe arg offsets. */
|
|
|
|
DTRACE_DOF_SECT_TYPE_PROFFS = 18,
|
|
|
|
/* An array of probe is-enabled offsets. */
|
|
|
|
DTRACE_DOF_SECT_TYPE_PRENOFFS = 26
|
|
|
|
};
|
|
|
|
|
|
|
|
/* The following collection of data structures map the structure of
|
|
|
|
DOF entities. Again, we only cover the subset of DOF used to
|
|
|
|
implement USDT probes.
|
|
|
|
|
|
|
|
See linux/dtrace/dof.h header for a complete list of data
|
|
|
|
structures. */
|
|
|
|
|
|
|
|
/* Offsets to index the dofh_ident[] array defined below. */
|
|
|
|
|
|
|
|
enum dtrace_dof_ident
|
|
|
|
{
|
|
|
|
/* First byte of the magic number. */
|
|
|
|
DTRACE_DOF_ID_MAG0 = 0,
|
|
|
|
/* Second byte of the magic number. */
|
|
|
|
DTRACE_DOF_ID_MAG1 = 1,
|
|
|
|
/* Third byte of the magic number. */
|
|
|
|
DTRACE_DOF_ID_MAG2 = 2,
|
|
|
|
/* Fourth byte of the magic number. */
|
|
|
|
DTRACE_DOF_ID_MAG3 = 3,
|
|
|
|
/* An enum_dof_encoding value. */
|
|
|
|
DTRACE_DOF_ID_ENCODING = 5
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Possible values for dofh_ident[DOF_ID_ENCODING]. */
|
|
|
|
|
|
|
|
enum dtrace_dof_encoding
|
|
|
|
{
|
|
|
|
/* The DOF program is little-endian. */
|
|
|
|
DTRACE_DOF_ENCODE_LSB = 1,
|
|
|
|
/* The DOF program is big-endian. */
|
|
|
|
DTRACE_DOF_ENCODE_MSB = 2
|
|
|
|
};
|
|
|
|
|
|
|
|
/* A DOF header, which describes the contents of a DOF program: number
|
|
|
|
of sections, size, etc. */
|
|
|
|
|
|
|
|
struct dtrace_dof_hdr
|
|
|
|
{
|
|
|
|
/* Identification bytes (see above). */
|
|
|
|
uint8_t dofh_ident[16];
|
|
|
|
/* File attribute flags (if any). */
|
|
|
|
uint32_t dofh_flags;
|
|
|
|
/* Size of file header in bytes. */
|
|
|
|
uint32_t dofh_hdrsize;
|
|
|
|
/* Size of section header in bytes. */
|
|
|
|
uint32_t dofh_secsize;
|
|
|
|
/* Number of section headers. */
|
|
|
|
uint32_t dofh_secnum;
|
|
|
|
/* File offset of section headers. */
|
|
|
|
uint64_t dofh_secoff;
|
|
|
|
/* File size of loadable portion. */
|
|
|
|
uint64_t dofh_loadsz;
|
|
|
|
/* File size of entire DOF file. */
|
|
|
|
uint64_t dofh_filesz;
|
|
|
|
/* Reserved for future use. */
|
|
|
|
uint64_t dofh_pad;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* A DOF section, whose contents depend on its type. The several
|
|
|
|
supported section types are described in the enum
|
|
|
|
dtrace_dof_sect_type above. */
|
|
|
|
|
|
|
|
struct dtrace_dof_sect
|
|
|
|
{
|
|
|
|
/* Section type (see the define above). */
|
|
|
|
uint32_t dofs_type;
|
|
|
|
/* Section data memory alignment. */
|
|
|
|
uint32_t dofs_align;
|
|
|
|
/* Section flags (if any). */
|
|
|
|
uint32_t dofs_flags;
|
|
|
|
/* Size of section entry (if table). */
|
|
|
|
uint32_t dofs_entsize;
|
|
|
|
/* DOF + offset points to the section data. */
|
|
|
|
uint64_t dofs_offset;
|
|
|
|
/* Size of section data in bytes. */
|
|
|
|
uint64_t dofs_size;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* A DOF provider, which is the provider of a probe. */
|
|
|
|
|
|
|
|
struct dtrace_dof_provider
|
|
|
|
{
|
|
|
|
/* Link to a DTRACE_DOF_SECT_TYPE_STRTAB section. */
|
|
|
|
uint32_t dofpv_strtab;
|
|
|
|
/* Link to a DTRACE_DOF_SECT_TYPE_PROBES section. */
|
|
|
|
uint32_t dofpv_probes;
|
|
|
|
/* Link to a DTRACE_DOF_SECT_TYPE_PRARGS section. */
|
|
|
|
uint32_t dofpv_prargs;
|
|
|
|
/* Link to a DTRACE_DOF_SECT_TYPE_PROFFS section. */
|
|
|
|
uint32_t dofpv_proffs;
|
|
|
|
/* Provider name string. */
|
|
|
|
uint32_t dofpv_name;
|
|
|
|
/* Provider attributes. */
|
|
|
|
uint32_t dofpv_provattr;
|
|
|
|
/* Module attributes. */
|
|
|
|
uint32_t dofpv_modattr;
|
|
|
|
/* Function attributes. */
|
|
|
|
uint32_t dofpv_funcattr;
|
|
|
|
/* Name attributes. */
|
|
|
|
uint32_t dofpv_nameattr;
|
|
|
|
/* Args attributes. */
|
|
|
|
uint32_t dofpv_argsattr;
|
|
|
|
/* Link to a DTRACE_DOF_SECT_PRENOFFS section. */
|
|
|
|
uint32_t dofpv_prenoffs;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* A set of DOF probes and is-enabled probes sharing a base address
|
|
|
|
and several attributes. The particular locations and attributes of
|
|
|
|
each probe are maintained in arrays in several other DOF sections.
|
|
|
|
See the comment in dtrace_process_dof_probe for details on how
|
|
|
|
these attributes are stored. */
|
|
|
|
|
|
|
|
struct dtrace_dof_probe
|
|
|
|
{
|
|
|
|
/* Probe base address or offset. */
|
|
|
|
uint64_t dofpr_addr;
|
|
|
|
/* Probe function string. */
|
|
|
|
uint32_t dofpr_func;
|
|
|
|
/* Probe name string. */
|
|
|
|
uint32_t dofpr_name;
|
|
|
|
/* Native argument type strings. */
|
|
|
|
uint32_t dofpr_nargv;
|
|
|
|
/* Translated argument type strings. */
|
|
|
|
uint32_t dofpr_xargv;
|
|
|
|
/* Index of first argument mapping. */
|
|
|
|
uint32_t dofpr_argidx;
|
|
|
|
/* Index of first offset entry. */
|
|
|
|
uint32_t dofpr_offidx;
|
|
|
|
/* Native argument count. */
|
|
|
|
uint8_t dofpr_nargc;
|
|
|
|
/* Translated argument count. */
|
|
|
|
uint8_t dofpr_xargc;
|
|
|
|
/* Number of offset entries for probe. */
|
|
|
|
uint16_t dofpr_noffs;
|
|
|
|
/* Index of first is-enabled offset. */
|
|
|
|
uint32_t dofpr_enoffidx;
|
|
|
|
/* Number of is-enabled offsets. */
|
|
|
|
uint16_t dofpr_nenoffs;
|
|
|
|
/* Reserved for future use. */
|
|
|
|
uint16_t dofpr_pad1;
|
|
|
|
/* Reserved for future use. */
|
|
|
|
uint32_t dofpr_pad2;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* DOF supports two different encodings: MSB (big-endian) and LSB
|
|
|
|
(little-endian). The encoding is itself encoded in the DOF header.
|
|
|
|
The following function returns an unsigned value in the host
|
|
|
|
endianness. */
|
|
|
|
|
|
|
|
#define DOF_UINT(dof, field) \
|
|
|
|
extract_unsigned_integer ((gdb_byte *) &(field), \
|
|
|
|
sizeof ((field)), \
|
|
|
|
(((dof)->dofh_ident[DTRACE_DOF_ID_ENCODING] \
|
|
|
|
== DTRACE_DOF_ENCODE_MSB) \
|
|
|
|
? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE))
|
|
|
|
|
|
|
|
/* The following macro applies a given byte offset to a DOF (a pointer
|
|
|
|
to a dtrace_dof_hdr structure) and returns the resulting
|
|
|
|
address. */
|
|
|
|
|
|
|
|
#define DTRACE_DOF_PTR(dof, offset) (&((char *) (dof))[(offset)])
|
|
|
|
|
|
|
|
/* The following macro returns a pointer to the beginning of a given
|
|
|
|
section in a DOF object. The section is referred to by its index
|
|
|
|
in the sections array. */
|
|
|
|
|
|
|
|
#define DTRACE_DOF_SECT(dof, idx) \
|
|
|
|
((struct dtrace_dof_sect *) \
|
|
|
|
DTRACE_DOF_PTR ((dof), \
|
|
|
|
DOF_UINT ((dof), (dof)->dofh_secoff) \
|
|
|
|
+ ((idx) * DOF_UINT ((dof), (dof)->dofh_secsize))))
|
|
|
|
|
|
|
|
/* Helper function to examine the probe described by the given PROBE
|
|
|
|
and PROVIDER data structures and add it to the PROBESP vector.
|
|
|
|
STRTAB, OFFTAB, EOFFTAB and ARGTAB are pointers to tables in the
|
|
|
|
DOF program containing the attributes for the probe. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
dtrace_process_dof_probe (struct objfile *objfile,
|
|
|
|
struct gdbarch *gdbarch, VEC (probe_p) **probesp,
|
|
|
|
struct dtrace_dof_hdr *dof,
|
|
|
|
struct dtrace_dof_probe *probe,
|
|
|
|
struct dtrace_dof_provider *provider,
|
|
|
|
char *strtab, char *offtab, char *eofftab,
|
|
|
|
char *argtab, uint64_t strtab_size)
|
|
|
|
{
|
|
|
|
int i, j, num_probes, num_enablers;
|
|
|
|
struct cleanup *cleanup;
|
|
|
|
VEC (dtrace_probe_enabler_s) *enablers;
|
|
|
|
char *p;
|
|
|
|
|
|
|
|
/* Each probe section can define zero or more probes of two
|
|
|
|
different types:
|
|
|
|
|
|
|
|
- probe->dofpr_noffs regular probes whose program counters are
|
|
|
|
stored in 32bit words starting at probe->dofpr_addr +
|
|
|
|
offtab[probe->dofpr_offidx].
|
|
|
|
|
|
|
|
- probe->dofpr_nenoffs is-enabled probes whose program counters
|
|
|
|
are stored in 32bit words starting at probe->dofpr_addr +
|
|
|
|
eofftab[probe->dofpr_enoffidx].
|
|
|
|
|
|
|
|
However is-enabled probes are not probes per-se, but an
|
|
|
|
optimization hack that is implemented in the kernel in a very
|
|
|
|
similar way than normal probes. This is how we support
|
|
|
|
is-enabled probes on GDB:
|
|
|
|
|
|
|
|
- Our probes are always DTrace regular probes.
|
|
|
|
|
|
|
|
- Our probes can be associated with zero or more "enablers". The
|
|
|
|
list of enablers is built from the is-enabled probes defined in
|
|
|
|
the Probe section.
|
|
|
|
|
|
|
|
- Probes having a non-empty list of enablers can be enabled or
|
|
|
|
disabled using the `enable probe' and `disable probe' commands
|
|
|
|
respectively. The `Enabled' column in the output of `info
|
|
|
|
probes' will read `yes' if the enablers are activated, `no'
|
|
|
|
otherwise.
|
|
|
|
|
|
|
|
- Probes having an empty list of enablers are always enabled.
|
|
|
|
The `Enabled' column in the output of `info probes' will
|
|
|
|
read `always'.
|
|
|
|
|
|
|
|
It follows that if there are DTrace is-enabled probes defined for
|
|
|
|
some provider/name but no DTrace regular probes defined then the
|
|
|
|
GDB user wont be able to enable/disable these conditionals. */
|
|
|
|
|
|
|
|
num_probes = DOF_UINT (dof, probe->dofpr_noffs);
|
|
|
|
if (num_probes == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Build the list of enablers for the probes defined in this Probe
|
|
|
|
DOF section. */
|
|
|
|
enablers = NULL;
|
|
|
|
cleanup
|
|
|
|
= make_cleanup (VEC_cleanup (dtrace_probe_enabler_s), &enablers);
|
|
|
|
num_enablers = DOF_UINT (dof, probe->dofpr_nenoffs);
|
|
|
|
for (i = 0; i < num_enablers; i++)
|
|
|
|
{
|
|
|
|
struct dtrace_probe_enabler enabler;
|
|
|
|
uint32_t enabler_offset
|
|
|
|
= ((uint32_t *) eofftab)[DOF_UINT (dof, probe->dofpr_enoffidx) + i];
|
|
|
|
|
|
|
|
enabler.address = DOF_UINT (dof, probe->dofpr_addr)
|
|
|
|
+ DOF_UINT (dof, enabler_offset);
|
|
|
|
VEC_safe_push (dtrace_probe_enabler_s, enablers, &enabler);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < num_probes; i++)
|
|
|
|
{
|
|
|
|
uint32_t probe_offset
|
|
|
|
= ((uint32_t *) offtab)[DOF_UINT (dof, probe->dofpr_offidx) + i];
|
Replace some xmalloc-family functions with XNEW-family ones
This patch is part of the make-gdb-buildable-in-C++ effort. The idea is
to change some calls to the xmalloc family of functions to calls to the
equivalents in the XNEW family. This avoids adding an explicit cast, so
it keeps the code a bit more readable. Some of them also map relatively
well to a C++ equivalent (XNEW (struct foo) -> new foo), so it will be
possible to do scripted replacements if needed.
I only changed calls that were obviously allocating memory for one or
multiple "objects". Allocation of variable sizes (such as strings or
buffer handling) will be for later (and won't use XNEW).
- xmalloc (sizeof (struct foo)) -> XNEW (struct foo)
- xmalloc (num * sizeof (struct foo)) -> XNEWVEC (struct foo, num)
- xcalloc (1, sizeof (struct foo)) -> XCNEW (struct foo)
- xcalloc (num, sizeof (struct foo)) -> XCNEWVEC (struct foo, num)
- xrealloc (p, num * sizeof (struct foo) -> XRESIZEVEC (struct foo, p, num)
- obstack_alloc (ob, sizeof (struct foo)) -> XOBNEW (ob, struct foo)
- obstack_alloc (ob, num * sizeof (struct foo)) -> XOBNEWVEC (ob, struct foo, num)
- alloca (sizeof (struct foo)) -> XALLOCA (struct foo)
- alloca (num * sizeof (struct foo)) -> XALLOCAVEC (struct foo, num)
Some instances of xmalloc followed by memset to zero the buffer were
replaced by XCNEW or XCNEWVEC.
I regtested on x86-64, Ubuntu 14.04, but the patch touches many
architecture-specific files. For those I'll have to rely on the
buildbot or people complaining that I broke their gdb.
gdb/ChangeLog:
* aarch64-linux-nat.c (aarch64_add_process): Likewise.
* aarch64-tdep.c (aarch64_gdbarch_init): Likewise.
* ada-exp.y (write_ambiguous_var): Likewise.
* ada-lang.c (resolve_subexp): Likewise.
(user_select_syms): Likewise.
(assign_aggregate): Likewise.
(ada_evaluate_subexp): Likewise.
(cache_symbol): Likewise.
* addrmap.c (allocate_key): Likewise.
(addrmap_create_mutable): Likewise.
* aix-thread.c (sync_threadlists): Likewise.
* alpha-tdep.c (alpha_push_dummy_call): Likewise.
(alpha_gdbarch_init): Likewise.
* amd64-windows-tdep.c (amd64_windows_push_arguments): Likewise.
* arm-linux-nat.c (arm_linux_add_process): Likewise.
* arm-linux-tdep.c (arm_linux_displaced_step_copy_insn): Likewise.
* arm-tdep.c (push_stack_item): Likewise.
(arm_displaced_step_copy_insn): Likewise.
(arm_gdbarch_init): Likewise.
(_initialize_arm_tdep): Likewise.
* avr-tdep.c (push_stack_item): Likewise.
* ax-general.c (new_agent_expr): Likewise.
* block.c (block_initialize_namespace): Likewise.
* breakpoint.c (alloc_counted_command_line): Likewise.
(update_dprintf_command_list): Likewise.
(parse_breakpoint_sals): Likewise.
(decode_static_tracepoint_spec): Likewise.
(until_break_command): Likewise.
(clear_command): Likewise.
(update_global_location_list): Likewise.
(get_breakpoint_objfile_data) Likewise.
* btrace.c (ftrace_new_function): Likewise.
(btrace_set_insn_history): Likewise.
(btrace_set_call_history): Likewise.
* buildsym.c (add_symbol_to_list): Likewise.
(record_pending_block): Likewise.
(start_subfile): Likewise.
(start_buildsym_compunit): Likewise.
(push_subfile): Likewise.
(end_symtab_get_static_block): Likewise.
(buildsym_init): Likewise.
* cli/cli-cmds.c (source_command): Likewise.
* cli/cli-decode.c (add_cmd): Likewise.
* cli/cli-script.c (build_command_line): Likewise.
(setup_user_args): Likewise.
(realloc_body_list): Likewise.
(process_next_line): Likewise.
(copy_command_lines): Likewise.
* cli/cli-setshow.c (do_set_command): Likewise.
* coff-pe-read.c (read_pe_exported_syms): Likewise.
* coffread.c (coff_locate_sections): Likewise.
(coff_symtab_read): Likewise.
(coff_read_struct_type): Likewise.
* common/cleanups.c (make_my_cleanup2): Likewise.
* common/common-exceptions.c (throw_it): Likewise.
* common/filestuff.c (make_cleanup_close): Likewise.
* common/format.c (parse_format_string): Likewise.
* common/queue.h (DEFINE_QUEUE_P): Likewise.
* compile/compile-object-load.c (munmap_list_add): Likewise.
(compile_object_load): Likewise.
* compile/compile-object-run.c (compile_object_run): Likewise.
* compile/compile.c (append_args): Likewise.
* corefile.c (specify_exec_file_hook): Likewise.
* cp-support.c (make_symbol_overload_list): Likewise.
* cris-tdep.c (push_stack_item): Likewise.
(cris_gdbarch_init): Likewise.
* ctf.c (ctf_trace_file_writer_new): Likewise.
* dbxread.c (init_header_files): Likewise.
(add_new_header_file): Likewise.
(init_bincl_list): Likewise.
(dbx_end_psymtab): Likewise.
(start_psymtab): Likewise.
(dbx_end_psymtab): Likewise.
* dcache.c (dcache_init): Likewise.
* dictionary.c (dict_create_hashed): Likewise.
(dict_create_hashed_expandable): Likewise.
(dict_create_linear): Likewise.
(dict_create_linear_expandable): Likewise.
* dtrace-probe.c (dtrace_process_dof_probe): Likewise.
* dummy-frame.c (register_dummy_frame_dtor): Likewise.
* dwarf2-frame-tailcall.c (cache_new_ref1): Likewise.
* dwarf2-frame.c (dwarf2_build_frame_info): Likewise.
(decode_frame_entry_1): Likewise.
* dwarf2expr.c (new_dwarf_expr_context): Likewise.
* dwarf2loc.c (dwarf2_compile_expr_to_ax): Likewise.
* dwarf2read.c (dwarf2_has_info): Likewise.
(create_signatured_type_table_from_index): Likewise.
(dwarf2_read_index): Likewise.
(dw2_get_file_names_reader): Likewise.
(create_all_type_units): Likewise.
(read_cutu_die_from_dwo): Likewise.
(init_tu_and_read_dwo_dies): Likewise.
(init_cutu_and_read_dies): Likewise.
(create_all_comp_units): Likewise.
(queue_comp_unit): Likewise.
(inherit_abstract_dies): Likewise.
(read_call_site_scope): Likewise.
(dwarf2_add_field): Likewise.
(dwarf2_add_typedef): Likewise.
(dwarf2_add_member_fn): Likewise.
(attr_to_dynamic_prop): Likewise.
(abbrev_table_alloc_abbrev): Likewise.
(abbrev_table_read_table): Likewise.
(add_include_dir): Likewise.
(add_file_name): Likewise.
(dwarf_decode_line_header): Likewise.
(dwarf2_const_value_attr): Likewise.
(dwarf_alloc_block): Likewise.
(parse_macro_definition): Likewise.
(set_die_type): Likewise.
(write_psymtabs_to_index): Likewise.
(create_cus_from_index): Likewise.
(dwarf2_create_include_psymtab): Likewise.
(process_psymtab_comp_unit_reader): Likewise.
(build_type_psymtab_dependencies): Likewise.
(read_comp_units_from_section): Likewise.
(compute_compunit_symtab_includes): Likewise.
(create_dwo_unit_in_dwp_v1): Likewise.
(create_dwo_unit_in_dwp_v2): Likewise.
(read_func_scope): Likewise.
(process_structure_scope): Likewise.
(mark_common_block_symbol_computed): Likewise.
(load_partial_dies): Likewise.
(dwarf2_symbol_mark_computed): Likewise.
* elfread.c (elf_symfile_segments): Likewise.
(elf_read_minimal_symbols): Likewise.
* environ.c (make_environ): Likewise.
* eval.c (evaluate_subexp_standard): Likewise.
* event-loop.c (create_file_handler): Likewise.
(create_async_signal_handler): Likewise.
(create_async_event_handler): Likewise.
(create_timer): Likewise.
* exec.c (build_section_table): Likewise.
* fbsd-nat.c (fbsd_remember_child): Likewise.
* fork-child.c (fork_inferior): Likewise.
* frv-tdep.c (new_variant): Likewise.
* gdbarch.sh (gdbarch_alloc): Likewise.
(append_name): Likewise.
* gdbtypes.c (rank_function): Likewise.
(copy_type_recursive): Likewise.
(add_dyn_prop): Likewise.
* gnu-nat.c (make_proc): Likewise.
(make_inf): Likewise.
(gnu_write_inferior): Likewise.
* gnu-v3-abi.c (build_gdb_vtable_type): Likewise.
(build_std_type_info_type): Likewise.
* guile/scm-param.c (compute_enum_list): Likewise.
* guile/scm-utils.c (gdbscm_parse_function_args): Likewise.
* guile/scm-value.c (gdbscm_value_call): Likewise.
* h8300-tdep.c (h8300_gdbarch_init): Likewise.
* hppa-tdep.c (hppa_init_objfile_priv_data): Likewise.
(read_unwind_info): Likewise.
* ia64-tdep.c (ia64_gdbarch_init): Likewise.
* infcall.c (dummy_frame_context_saver_setup): Likewise.
(call_function_by_hand_dummy): Likewise.
* infcmd.c (step_once): Likewise.
(finish_forward): Likewise.
(attach_command): Likewise.
(notice_new_inferior): Likewise.
* inferior.c (add_inferior_silent): Likewise.
* infrun.c (add_displaced_stepping_state): Likewise.
(save_infcall_control_state): Likewise.
(save_inferior_ptid): Likewise.
(_initialize_infrun): Likewise.
* jit.c (bfd_open_from_target_memory): Likewise.
(jit_gdbarch_data_init): Likewise.
* language.c (add_language): Likewise.
* linespec.c (decode_line_2): Likewise.
* linux-nat.c (add_to_pid_list): Likewise.
(add_initial_lwp): Likewise.
* linux-thread-db.c (add_thread_db_info): Likewise.
(record_thread): Likewise.
(info_auto_load_libthread_db): Likewise.
* m32c-tdep.c (m32c_gdbarch_init): Likewise.
* m68hc11-tdep.c (m68hc11_gdbarch_init): Likewise.
* m68k-tdep.c (m68k_gdbarch_init): Likewise.
* m88k-tdep.c (m88k_analyze_prologue): Likewise.
* macrocmd.c (macro_define_command): Likewise.
* macroexp.c (gather_arguments): Likewise.
* macroscope.c (sal_macro_scope): Likewise.
* macrotab.c (new_macro_table): Likewise.
* mdebugread.c (push_parse_stack): Likewise.
(parse_partial_symbols): Likewise.
(parse_symbol): Likewise.
(psymtab_to_symtab_1): Likewise.
(new_block): Likewise.
(new_psymtab): Likewise.
(mdebug_build_psymtabs): Likewise.
(add_pending): Likewise.
(elfmdebug_build_psymtabs): Likewise.
* mep-tdep.c (mep_gdbarch_init): Likewise.
* mi/mi-main.c (mi_execute_command): Likewise.
* mi/mi-parse.c (mi_parse_argv): Likewise.
* minidebug.c (lzma_open): Likewise.
* minsyms.c (terminate_minimal_symbol_table): Likewise.
* mips-linux-nat.c (mips_linux_insert_watchpoint): Likewise.
* mips-tdep.c (mips_gdbarch_init): Likewise.
* mn10300-tdep.c (mn10300_gdbarch_init): Likewise.
* msp430-tdep.c (msp430_gdbarch_init): Likewise.
* mt-tdep.c (mt_registers_info): Likewise.
* nat/aarch64-linux.c (aarch64_linux_new_thread): Likewise.
* nat/linux-btrace.c (linux_enable_bts): Likewise.
(linux_enable_pt): Likewise.
* nat/linux-osdata.c (linux_xfer_osdata_processes): Likewise.
(linux_xfer_osdata_processgroups): Likewise.
* nios2-tdep.c (nios2_gdbarch_init): Likewise.
* nto-procfs.c (procfs_meminfo): Likewise.
* objc-lang.c (start_msglist): Likewise.
(selectors_info): Likewise.
(classes_info): Likewise.
(find_methods): Likewise.
* objfiles.c (allocate_objfile): Likewise.
(update_section_map): Likewise.
* osabi.c (gdbarch_register_osabi): Likewise.
(gdbarch_register_osabi_sniffer): Likewise.
* parse.c (start_arglist): Likewise.
* ppc-linux-nat.c (hwdebug_find_thread_points_by_tid): Likewise.
(hwdebug_insert_point): Likewise.
* printcmd.c (display_command): Likewise.
(ui_printf): Likewise.
* procfs.c (create_procinfo): Likewise.
(load_syscalls): Likewise.
(proc_get_LDT_entry): Likewise.
(proc_update_threads): Likewise.
* prologue-value.c (make_pv_area): Likewise.
(pv_area_store): Likewise.
* psymtab.c (extend_psymbol_list): Likewise.
(init_psymbol_list): Likewise.
(allocate_psymtab): Likewise.
* python/py-inferior.c (add_thread_object): Likewise.
* python/py-param.c (compute_enum_values): Likewise.
* python/py-value.c (valpy_call): Likewise.
* python/py-varobj.c (py_varobj_iter_next): Likewise.
* python/python.c (ensure_python_env): Likewise.
* record-btrace.c (record_btrace_start_replaying): Likewise.
* record-full.c (record_full_reg_alloc): Likewise.
(record_full_mem_alloc): Likewise.
(record_full_end_alloc): Likewise.
(record_full_core_xfer_partial): Likewise.
* regcache.c (get_thread_arch_aspace_regcache): Likewise.
* remote-fileio.c (remote_fileio_init_fd_map): Likewise.
* remote-notif.c (remote_notif_state_allocate): Likewise.
* remote.c (demand_private_info): Likewise.
(remote_notif_stop_alloc_reply): Likewise.
(remote_enable_btrace): Likewise.
* reverse.c (save_bookmark_command): Likewise.
* rl78-tdep.c (rl78_gdbarch_init): Likewise.
* rx-tdep.c (rx_gdbarch_init): Likewise.
* s390-linux-nat.c (s390_insert_watchpoint): Likewise.
* ser-go32.c (dos_get_tty_state): Likewise.
(dos_copy_tty_state): Likewise.
* ser-mingw.c (ser_windows_open): Likewise.
(ser_console_wait_handle): Likewise.
(ser_console_get_tty_state): Likewise.
(make_pipe_state): Likewise.
(net_windows_open): Likewise.
* ser-unix.c (hardwire_get_tty_state): Likewise.
(hardwire_copy_tty_state): Likewise.
* solib-aix.c (solib_aix_new_lm_info): Likewise.
* solib-dsbt.c (dsbt_current_sos): Likewise.
(dsbt_relocate_main_executable): Likewise.
* solib-frv.c (frv_current_sos): Likewise.
(frv_relocate_main_executable): Likewise.
* solib-spu.c (spu_bfd_fopen): Likewise.
* solib-svr4.c (lm_info_read): Likewise.
(svr4_copy_library_list): Likewise.
(svr4_default_sos): Likewise.
* source.c (find_source_lines): Likewise.
(line_info): Likewise.
(add_substitute_path_rule): Likewise.
* spu-linux-nat.c (spu_bfd_open): Likewise.
* spu-tdep.c (info_spu_dma_cmdlist): Likewise.
* stabsread.c (dbx_lookup_type): Likewise.
(read_type): Likewise.
(read_member_functions): Likewise.
(read_struct_fields): Likewise.
(read_baseclasses): Likewise.
(read_args): Likewise.
(_initialize_stabsread): Likewise.
* stack.c (func_command): Likewise.
* stap-probe.c (handle_stap_probe): Likewise.
* symfile.c (addrs_section_sort): Likewise.
(addr_info_make_relative): Likewise.
(load_section_callback): Likewise.
(add_symbol_file_command): Likewise.
(init_filename_language_table): Likewise.
* symtab.c (create_filename_seen_cache): Likewise.
(sort_search_symbols_remove_dups): Likewise.
(search_symbols): Likewise.
* target.c (make_cleanup_restore_target_terminal): Likewise.
* thread.c (new_thread): Likewise.
(enable_thread_stack_temporaries): Likewise.
(make_cleanup_restore_current_thread): Likewise.
(thread_apply_all_command): Likewise.
* tic6x-tdep.c (tic6x_gdbarch_init): Likewise.
* top.c (gdb_readline_wrapper): Likewise.
* tracefile-tfile.c (tfile_trace_file_writer_new): Likewise.
* tracepoint.c (trace_find_line_command): Likewise.
(all_tracepoint_actions_and_cleanup): Likewise.
(make_cleanup_restore_current_traceframe): Likewise.
(get_uploaded_tp): Likewise.
(get_uploaded_tsv): Likewise.
* tui/tui-data.c (tui_alloc_generic_win_info): Likewise.
(tui_alloc_win_info): Likewise.
(tui_alloc_content): Likewise.
(tui_add_content_elements): Likewise.
* tui/tui-disasm.c (tui_find_disassembly_address): Likewise.
(tui_set_disassem_content): Likewise.
* ui-file.c (ui_file_new): Likewise.
(stdio_file_new): Likewise.
(tee_file_new): Likewise.
* utils.c (make_cleanup_restore_integer): Likewise.
(add_internal_problem_command): Likewise.
* v850-tdep.c (v850_gdbarch_init): Likewise.
* valops.c (find_oload_champ): Likewise.
* value.c (allocate_value_lazy): Likewise.
(record_latest_value): Likewise.
(create_internalvar): Likewise.
* varobj.c (install_variable): Likewise.
(new_variable): Likewise.
(new_root_variable): Likewise.
(cppush): Likewise.
(_initialize_varobj): Likewise.
* windows-nat.c (windows_make_so): Likewise.
* x86-nat.c (x86_add_process): Likewise.
* xcoffread.c (arrange_linetable): Likewise.
(allocate_include_entry): Likewise.
(process_linenos): Likewise.
(SYMBOL_DUP): Likewise.
(xcoff_start_psymtab): Likewise.
(xcoff_end_psymtab): Likewise.
* xml-support.c (gdb_xml_parse_attr_ulongest): Likewise.
* xtensa-tdep.c (xtensa_register_type): Likewise.
* gdbarch.c: Regenerate.
* gdbarch.h: Regenerate.
gdb/gdbserver/ChangeLog:
* ax.c (gdb_parse_agent_expr): Likewise.
(compile_bytecodes): Likewise.
* dll.c (loaded_dll): Likewise.
* event-loop.c (append_callback_event): Likewise.
(create_file_handler): Likewise.
(create_file_event): Likewise.
* hostio.c (handle_open): Likewise.
* inferiors.c (add_thread): Likewise.
(add_process): Likewise.
* linux-aarch64-low.c (aarch64_linux_new_process): Likewise.
* linux-arm-low.c (arm_new_process): Likewise.
(arm_new_thread): Likewise.
* linux-low.c (add_to_pid_list): Likewise.
(linux_add_process): Likewise.
(handle_extended_wait): Likewise.
(add_lwp): Likewise.
(enqueue_one_deferred_signal): Likewise.
(enqueue_pending_signal): Likewise.
(linux_resume_one_lwp_throw): Likewise.
(linux_resume_one_thread): Likewise.
(linux_read_memory): Likewise.
(linux_write_memory): Likewise.
* linux-mips-low.c (mips_linux_new_process): Likewise.
(mips_linux_new_thread): Likewise.
(mips_add_watchpoint): Likewise.
* linux-x86-low.c (initialize_low_arch): Likewise.
* lynx-low.c (lynx_add_process): Likewise.
* mem-break.c (set_raw_breakpoint_at): Likewise.
(set_breakpoint): Likewise.
(add_condition_to_breakpoint): Likewise.
(add_commands_to_breakpoint): Likewise.
(clone_agent_expr): Likewise.
(clone_one_breakpoint): Likewise.
* regcache.c (new_register_cache): Likewise.
* remote-utils.c (look_up_one_symbol): Likewise.
* server.c (queue_stop_reply): Likewise.
(start_inferior): Likewise.
(queue_stop_reply_callback): Likewise.
(handle_target_event): Likewise.
* spu-low.c (fetch_ppc_memory): Likewise.
(store_ppc_memory): Likewise.
* target.c (set_target_ops): Likewise.
* thread-db.c (thread_db_load_search): Likewise.
(try_thread_db_load_1): Likewise.
* tracepoint.c (add_tracepoint): Likewise.
(add_tracepoint_action): Likewise.
(create_trace_state_variable): Likewise.
(cmd_qtdpsrc): Likewise.
(cmd_qtro): Likewise.
(add_while_stepping_state): Likewise.
* win32-low.c (child_add_thread): Likewise.
(get_image_name): Likewise.
2015-08-26 23:16:07 +02:00
|
|
|
struct dtrace_probe *ret =
|
|
|
|
XOBNEW (&objfile->per_bfd->storage_obstack, struct dtrace_probe);
|
2015-02-17 16:03:22 +01:00
|
|
|
|
|
|
|
ret->p.pops = &dtrace_probe_ops;
|
|
|
|
ret->p.arch = gdbarch;
|
|
|
|
ret->args_expr_built = 0;
|
|
|
|
|
|
|
|
/* Set the provider and the name of the probe. */
|
|
|
|
ret->p.provider
|
|
|
|
= xstrdup (strtab + DOF_UINT (dof, provider->dofpv_name));
|
|
|
|
ret->p.name = xstrdup (strtab + DOF_UINT (dof, probe->dofpr_name));
|
|
|
|
|
|
|
|
/* The probe address. */
|
|
|
|
ret->p.address
|
|
|
|
= DOF_UINT (dof, probe->dofpr_addr) + DOF_UINT (dof, probe_offset);
|
|
|
|
|
|
|
|
/* Number of arguments in the probe. */
|
|
|
|
ret->probe_argc = DOF_UINT (dof, probe->dofpr_nargc);
|
|
|
|
|
|
|
|
/* Store argument type descriptions. A description of the type
|
|
|
|
of the argument is in the (J+1)th null-terminated string
|
|
|
|
starting at 'strtab' + 'probe->dofpr_nargv'. */
|
|
|
|
ret->args = NULL;
|
|
|
|
p = strtab + DOF_UINT (dof, probe->dofpr_nargv);
|
|
|
|
for (j = 0; j < ret->probe_argc; j++)
|
|
|
|
{
|
|
|
|
struct dtrace_probe_arg arg;
|
'struct expression *' -> gdb::unique_xmalloc_ptr<expression>
This patch makes parse_expression and friends return a unique_ptr
instead of raw pointer [1]:
typedef gdb::unique_malloc_ptr<expression> expression_up;
and then adjusts the codebase throughout to stop using cleanups to
manage lifetime of expression pointers.
Whenever I found a structure owning an expression pointer, I made it
store a unique_ptr instead of a raw pointer, which then requires using
new/delete of the holding structure, instead of XNEW/xfree.
[1] - I'd like to set the rule that types named with an "_up" suffix
are unique_ptr typedefs.
Note I used gdb::unique_xmalloc_ptr instead of gdb::unique_ptr, simply
because we still use xmalloc instead of new to allocate expression
objects. Once that's changed, all we need to do is change the
expression_up typedef and the smart pointer will then call delete
instead of xfree.
gdb/ChangeLog:
2016-11-08 Pedro Alves <palves@redhat.com>
* ada-lang.c (ada_read_renaming_var_value): Use expression_up.
(struct ada_catchpoint_location) <excep_cond_expr>: Now an
expression_up.
(ada_catchpoint_location_dtor): Reset excep_cond_expr instead of
using xfree.
(create_excep_cond_exprs): Use expression_up and gdb::move.
(allocate_location_exception): Use new instead of XNEW.
(should_stop_exception): Likewise. Adjust to use expression_up.
(create_ada_exception_catchpoint): Use new instead of XNEW.
* ax-gdb.c (agent_eval_command_one): Use expression_up instead of
cleanups.
(maint_agent_printf_command): Use expression_up.
* break-catch-sig.c (create_signal_catchpoint): Use new instead of
XNEW.
* break-catch-syscall.c (create_syscall_event_catchpoint):
Likewise.
* break-catch-throw.c (handle_gnu_v3_exceptions): Use new instead
of XCNEW. Use gdb::unique_ptr instead of cleanups.
* breakpoint.c (set_breakpoint_condition, update_watchpoint)
(parse_cmd_to_aexpr, watchpoint_check)
(bpstat_check_breakpoint_conditions, watchpoint_locations_match):
Adjust to use expression_up.
(init_bp_location): Adjust.
(free_bp_location): Use delete instead of xfree.
(set_raw_breakpoint_without_location, set_raw_breakpoint)
(add_solib_catchpoint, create_fork_vfork_event_catchpoint)
(new_single_step_breakpoint, create_breakpoint_sal): Use new
instead of XNEW.
(find_condition_and_thread): Adjust to use expression_up.
(create_breakpoint): Use new instead of XNEW.
(dtor_watchpoint): Don't xfree expression pointers, they're
unique_ptr's now.
(insert_watchpoint, remove_watchpoint): Adjust.
(watch_command_1): Use expression_up. Use new instead of XCNEW.
(catch_exec_command_1): Use new instead of XNEW.
(bp_location_dtor): Don't xfree expression pointers, they're
unique_ptr's now.
(base_breakpoint_allocate_location)
(strace_marker_create_breakpoints_sal): Use new instead of XNEW.
(delete_breakpoint): Use delete instead of xfree.
* breakpoint.h (struct bp_location) <cond>: Now an
unique_ptr<expression> instead of a raw pointer.
(struct watchpoint) <exp, cond_exp>: Likewise.
* cli/cli-script.c (execute_control_command): Use expression_up
instead of cleanups.
* dtrace-probe.c (dtrace_process_dof_probe): Use expression_up.
* eval.c (parse_and_eval_address, parse_and_eval_long)
(parse_and_eval, parse_to_comma_and_eval, parse_and_eval_type):
Use expression_up instead of cleanups.
* expression.h (expression_up): New typedef.
(parse_expression, parse_expression_with_language, parse_exp_1):
Change return type to expression_up.
* mi/mi-main.c (mi_cmd_data_evaluate_expression)
(print_variable_or_computed): Use expression_up.
* objc-lang.c (print_object_command): Use expression_up instead of
cleanups.
* parse.c (parse_exp_1, parse_exp_in_context)
(parse_exp_in_context_1, parse_expression)
(parse_expression_with_language): Return an expression_up instead
of a raw pointer.
(parse_expression_for_completion): Use expression_up.
* printcmd.c (struct display) <exp>: Now an expression_up instead
of a raw pointer.
(print_command_1, output_command_const, set_command, x_command):
Use expression_up instead of cleanups.
(display_command): Likewise. Use new instead of XNEW.
(free_display): Use delete instead of xfree.
(do_one_display): Adjust to use expression_up.
* remote.c (remote_download_tracepoint): Likewise.
* stack.c (return_command): Likewise.
* tracepoint.c (validate_actionline, encode_actions_1): Use
expression_up instead of cleanups.
* typeprint.c (whatis_exp, maintenance_print_type): Likewise.
* value.c (init_if_undefined_command): Likewise.
* varobj.c (struct varobj_root) <exp>: Now an expression_up
instead of a raw pointer.
(varobj_create): Adjust.
(varobj_set_value): Use an expression_up instead of cleanups.
(new_root_variable): Use new instead of XNEW.
(free_variable): Use delete instead of xfree.
(value_of_root_1): Use std::swap.
2016-11-08 16:26:43 +01:00
|
|
|
expression_up expr;
|
2015-02-17 16:03:22 +01:00
|
|
|
|
2015-02-19 23:42:37 +01:00
|
|
|
/* Set arg.expr to ensure all fields in expr are initialized and
|
|
|
|
the compiler will not warn when arg is used. */
|
|
|
|
arg.expr = NULL;
|
2015-02-17 16:03:22 +01:00
|
|
|
arg.type_str = xstrdup (p);
|
|
|
|
|
|
|
|
/* Use strtab_size as a sentinel. */
|
2017-06-25 12:49:19 +02:00
|
|
|
while (*p++ != '\0' && p - strtab < strtab_size)
|
|
|
|
;
|
2015-02-17 16:03:22 +01:00
|
|
|
|
|
|
|
/* Try to parse a type expression from the type string. If
|
|
|
|
this does not work then we set the type to `long
|
|
|
|
int'. */
|
|
|
|
arg.type = builtin_type (gdbarch)->builtin_long;
|
2015-03-26 19:14:03 +01:00
|
|
|
|
|
|
|
TRY
|
|
|
|
{
|
2016-11-24 21:01:24 +01:00
|
|
|
expr = parse_expression_with_language (arg.type_str, language_c);
|
2015-03-26 19:14:03 +01:00
|
|
|
}
|
|
|
|
CATCH (ex, RETURN_MASK_ERROR)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
END_CATCH
|
|
|
|
|
|
|
|
if (expr != NULL && expr->elts[0].opcode == OP_TYPE)
|
2015-02-17 16:03:22 +01:00
|
|
|
arg.type = expr->elts[1].type;
|
|
|
|
|
|
|
|
VEC_safe_push (dtrace_probe_arg_s, ret->args, &arg);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Add the vector of enablers to this probe, if any. */
|
|
|
|
ret->enablers = VEC_copy (dtrace_probe_enabler_s, enablers);
|
|
|
|
|
|
|
|
/* Successfully created probe. */
|
|
|
|
VEC_safe_push (probe_p, *probesp, (struct probe *) ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
do_cleanups (cleanup);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Helper function to collect the probes described in the DOF program
|
|
|
|
whose header is pointed by DOF and add them to the PROBESP vector.
|
|
|
|
SECT is the ELF section containing the DOF program and OBJFILE is
|
|
|
|
its containing object file. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
dtrace_process_dof (asection *sect, struct objfile *objfile,
|
|
|
|
VEC (probe_p) **probesp, struct dtrace_dof_hdr *dof)
|
|
|
|
{
|
|
|
|
struct gdbarch *gdbarch = get_objfile_arch (objfile);
|
|
|
|
struct dtrace_dof_sect *section;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* The first step is to check for the DOF magic number. If no valid
|
|
|
|
DOF data is found in the section then a complaint is issued to
|
|
|
|
the user and the section skipped. */
|
|
|
|
if (dof->dofh_ident[DTRACE_DOF_ID_MAG0] != 0x7F
|
|
|
|
|| dof->dofh_ident[DTRACE_DOF_ID_MAG1] != 'D'
|
|
|
|
|| dof->dofh_ident[DTRACE_DOF_ID_MAG2] != 'O'
|
|
|
|
|| dof->dofh_ident[DTRACE_DOF_ID_MAG3] != 'F')
|
|
|
|
goto invalid_dof_data;
|
|
|
|
|
|
|
|
/* Make sure the encoding mark is either DTRACE_DOF_ENCODE_LSB or
|
|
|
|
DTRACE_DOF_ENCODE_MSB. */
|
|
|
|
if (dof->dofh_ident[DTRACE_DOF_ID_ENCODING] != DTRACE_DOF_ENCODE_LSB
|
|
|
|
&& dof->dofh_ident[DTRACE_DOF_ID_ENCODING] != DTRACE_DOF_ENCODE_MSB)
|
|
|
|
goto invalid_dof_data;
|
|
|
|
|
|
|
|
/* Make sure this DOF is not an enabling DOF, i.e. there are no ECB
|
|
|
|
Description sections. */
|
|
|
|
section = (struct dtrace_dof_sect *) DTRACE_DOF_PTR (dof,
|
|
|
|
DOF_UINT (dof, dof->dofh_secoff));
|
|
|
|
for (i = 0; i < DOF_UINT (dof, dof->dofh_secnum); i++, section++)
|
|
|
|
if (section->dofs_type == DTRACE_DOF_SECT_TYPE_ECBDESC)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Iterate over any section of type Provider and extract the probe
|
|
|
|
information from them. If there are no "provider" sections on
|
|
|
|
the DOF then we just return. */
|
|
|
|
section = (struct dtrace_dof_sect *) DTRACE_DOF_PTR (dof,
|
|
|
|
DOF_UINT (dof, dof->dofh_secoff));
|
|
|
|
for (i = 0; i < DOF_UINT (dof, dof->dofh_secnum); i++, section++)
|
|
|
|
if (DOF_UINT (dof, section->dofs_type) == DTRACE_DOF_SECT_TYPE_PROVIDER)
|
|
|
|
{
|
|
|
|
struct dtrace_dof_provider *provider = (struct dtrace_dof_provider *)
|
|
|
|
DTRACE_DOF_PTR (dof, DOF_UINT (dof, section->dofs_offset));
|
|
|
|
struct dtrace_dof_sect *strtab_s
|
|
|
|
= DTRACE_DOF_SECT (dof, DOF_UINT (dof, provider->dofpv_strtab));
|
|
|
|
struct dtrace_dof_sect *probes_s
|
|
|
|
= DTRACE_DOF_SECT (dof, DOF_UINT (dof, provider->dofpv_probes));
|
|
|
|
struct dtrace_dof_sect *args_s
|
|
|
|
= DTRACE_DOF_SECT (dof, DOF_UINT (dof, provider->dofpv_prargs));
|
|
|
|
struct dtrace_dof_sect *offsets_s
|
|
|
|
= DTRACE_DOF_SECT (dof, DOF_UINT (dof, provider->dofpv_proffs));
|
|
|
|
struct dtrace_dof_sect *eoffsets_s
|
|
|
|
= DTRACE_DOF_SECT (dof, DOF_UINT (dof, provider->dofpv_prenoffs));
|
|
|
|
char *strtab = DTRACE_DOF_PTR (dof, DOF_UINT (dof, strtab_s->dofs_offset));
|
|
|
|
char *offtab = DTRACE_DOF_PTR (dof, DOF_UINT (dof, offsets_s->dofs_offset));
|
|
|
|
char *eofftab = DTRACE_DOF_PTR (dof, DOF_UINT (dof, eoffsets_s->dofs_offset));
|
|
|
|
char *argtab = DTRACE_DOF_PTR (dof, DOF_UINT (dof, args_s->dofs_offset));
|
|
|
|
unsigned int entsize = DOF_UINT (dof, probes_s->dofs_entsize);
|
|
|
|
int num_probes;
|
|
|
|
|
ignore invalid DOF provider sections
On x86-solaris 10, we noticed that starting a program would sometimes
cause the debugger to crash. For instance:
% gdb a
(gdb) break adainit
Breakpoint 1 at 0x8051f03
(gdb) run
Starting program: /[...]/a
[Thread debugging using libthread_db enabled]
zsh: 24398 segmentation fault (core dumped) /[...]/gdb a
The exception occurs in dtrace_process_dof_probe, while trying
to process each probe referenced by a DTRACE_DOF_SECT_TYPE_PROVIDER
DOF section from /lib/libc.so.1. For reference, the ELF section
in that shared library providing the DOF data has the following
characteristics:
Idx Name Size VMA LMA File off Algn
14 .SUNW_dof 0000109d 000b4398 000b4398 000b4398 2**3
CONTENTS, ALLOC, LOAD, READONLY, DATA
The function dtrace_process_dof gets passed the contents of that
ELF section, which allows it to determine the location of the table
where all DOF sections are described. I dumped the contents of
each DOF section as seen by GDB, and it seemed to be plausible,
because the offset of each DOF section was pretty much equal to
the sum of the offset and size of the previous DOF section. Also,
the offset + sum of the last section corresponds to the size of
the .SUNW_dof section.
Things start to break down when processing one of the DOF sections
that has a type of DTRACE_DOF_SECT_TYPE_PROVIDER. It gets the contents
of this DOF section via:
struct dtrace_dof_provider *provider = (struct dtrace_dof_provider *)
DTRACE_DOF_PTR (dof, DOF_UINT (dof, section->dofs_offset));
Said more simply, the struct dtrace_dof_provider data is at
section->dofs_offset of the entire DOF contents. Given that
the contents of SECTION seemed to make sense, so far so good.
However, what SECTION tells us is that our DOF provider section
is 40 bytes long:
(gdb) print *section
$36 = {dofs_type = 15, dofs_align = 4, dofs_flags = 1,
dofs_entsize = 0, dofs_offset = 3264, dofs_size = 40}
^^^^^^^^^^^^^^
But on the other hand:
(gdb) p sizeof (struct dtrace_dof_provider)
$54 = 44
In other words GDB expected a bigger DOF section and when we try to
fetch the value of the last field of that DOF section (dofpv_prenoffs)...
eoffsets_s = DTRACE_DOF_SECT (dof,
DOF_UINT (dof, provider->dofpv_prenoffs));
... we end up reading data that actually belongs to another DOF
section, and therefore irrelevant. This in turn means that the value
of eofftab gets incorrectly set, since it depends on eoffsets_s:
eofftab = DTRACE_DOF_PTR (dof, DOF_UINT (dof, eoffsets_s->dofs_offset));
This invalid address quickly catches up to us when we pass it to
dtrace_process_dof_probe shortly after, where we crash because
we try to subscript it:
Program received signal SIGSEGV, Segmentation fault.
0x08155bba in dtrace_process_dof_probe ([...]) at [...]/dtrace-probe.c:378
378 = ((uint32_t *) eofftab)[...];
This patch fixes the issue by detecting provider DOF sections
that are smaller than expected, and discarding the DOF data.
gdb/ChangeLog:
* dtrace-probe.c (dtrace_process_dof): Ignore the objfile's DOF
data if a DTRACE_DOF_SECT_TYPE_PROVIDER section is found to be
smaller than expected.
2015-08-06 22:13:32 +02:00
|
|
|
if (DOF_UINT (dof, section->dofs_size)
|
|
|
|
< sizeof (struct dtrace_dof_provider))
|
|
|
|
{
|
|
|
|
/* The section is smaller than expected, so do not use it.
|
|
|
|
This has been observed on x86-solaris 10. */
|
|
|
|
goto invalid_dof_data;
|
|
|
|
}
|
|
|
|
|
2015-02-17 16:03:22 +01:00
|
|
|
/* Very, unlikely, but could crash gdb if not handled
|
|
|
|
properly. */
|
|
|
|
if (entsize == 0)
|
|
|
|
goto invalid_dof_data;
|
|
|
|
|
|
|
|
num_probes = DOF_UINT (dof, probes_s->dofs_size) / entsize;
|
|
|
|
|
|
|
|
for (i = 0; i < num_probes; i++)
|
|
|
|
{
|
|
|
|
struct dtrace_dof_probe *probe = (struct dtrace_dof_probe *)
|
|
|
|
DTRACE_DOF_PTR (dof, DOF_UINT (dof, probes_s->dofs_offset)
|
|
|
|
+ (i * DOF_UINT (dof, probes_s->dofs_entsize)));
|
|
|
|
|
|
|
|
dtrace_process_dof_probe (objfile,
|
|
|
|
gdbarch, probesp,
|
|
|
|
dof, probe,
|
|
|
|
provider, strtab, offtab, eofftab, argtab,
|
|
|
|
DOF_UINT (dof, strtab_s->dofs_size));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
invalid_dof_data:
|
|
|
|
complaint (&symfile_complaints,
|
|
|
|
_("skipping section '%s' which does not contain valid DOF data."),
|
|
|
|
sect->name);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Helper function to build the GDB internal expressiosn that, once
|
|
|
|
evaluated, will calculate the values of the arguments of a given
|
|
|
|
PROBE. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
dtrace_build_arg_exprs (struct dtrace_probe *probe,
|
|
|
|
struct gdbarch *gdbarch)
|
|
|
|
{
|
|
|
|
struct parser_state pstate;
|
|
|
|
struct dtrace_probe_arg *arg;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
probe->args_expr_built = 1;
|
|
|
|
|
|
|
|
/* Iterate over the arguments in the probe and build the
|
|
|
|
corresponding GDB internal expression that will generate the
|
|
|
|
value of the argument when executed at the PC of the probe. */
|
|
|
|
for (i = 0; i < probe->probe_argc; i++)
|
|
|
|
{
|
|
|
|
struct cleanup *back_to;
|
|
|
|
|
|
|
|
arg = VEC_index (dtrace_probe_arg_s, probe->args, i);
|
|
|
|
|
|
|
|
/* Initialize the expression buffer in the parser state. The
|
|
|
|
language does not matter, since we are using our own
|
|
|
|
parser. */
|
|
|
|
initialize_expout (&pstate, 10, current_language, gdbarch);
|
|
|
|
back_to = make_cleanup (free_current_contents, &pstate.expout);
|
|
|
|
|
|
|
|
/* The argument value, which is ABI dependent and casted to
|
|
|
|
`long int'. */
|
|
|
|
gdbarch_dtrace_parse_probe_argument (gdbarch, &pstate, i);
|
|
|
|
|
|
|
|
discard_cleanups (back_to);
|
|
|
|
|
|
|
|
/* Casting to the expected type, but only if the type was
|
|
|
|
recognized at probe load time. Otherwise the argument will
|
|
|
|
be evaluated as the long integer passed to the probe. */
|
|
|
|
if (arg->type != NULL)
|
|
|
|
{
|
|
|
|
write_exp_elt_opcode (&pstate, UNOP_CAST);
|
|
|
|
write_exp_elt_type (&pstate, arg->type);
|
|
|
|
write_exp_elt_opcode (&pstate, UNOP_CAST);
|
|
|
|
}
|
|
|
|
|
|
|
|
reallocate_expout (&pstate);
|
|
|
|
arg->expr = pstate.expout;
|
|
|
|
prefixify_expression (arg->expr);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Helper function to return the Nth argument of a given PROBE. */
|
|
|
|
|
|
|
|
static struct dtrace_probe_arg *
|
|
|
|
dtrace_get_arg (struct dtrace_probe *probe, unsigned n,
|
|
|
|
struct gdbarch *gdbarch)
|
|
|
|
{
|
|
|
|
if (!probe->args_expr_built)
|
|
|
|
dtrace_build_arg_exprs (probe, gdbarch);
|
|
|
|
|
|
|
|
return VEC_index (dtrace_probe_arg_s, probe->args, n);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Implementation of the get_probes method. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
dtrace_get_probes (VEC (probe_p) **probesp, struct objfile *objfile)
|
|
|
|
{
|
|
|
|
bfd *abfd = objfile->obfd;
|
|
|
|
asection *sect = NULL;
|
|
|
|
|
|
|
|
/* Do nothing in case this is a .debug file, instead of the objfile
|
|
|
|
itself. */
|
|
|
|
if (objfile->separate_debug_objfile_backlink != NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Iterate over the sections in OBJFILE looking for DTrace
|
|
|
|
information. */
|
|
|
|
for (sect = abfd->sections; sect != NULL; sect = sect->next)
|
|
|
|
{
|
|
|
|
if (elf_section_data (sect)->this_hdr.sh_type == SHT_SUNW_dof)
|
|
|
|
{
|
2015-02-19 23:42:37 +01:00
|
|
|
bfd_byte *dof;
|
2015-02-17 16:03:22 +01:00
|
|
|
|
|
|
|
/* Read the contents of the DOF section and then process it to
|
|
|
|
extract the information of any probe defined into it. */
|
2015-02-19 23:42:37 +01:00
|
|
|
if (!bfd_malloc_and_get_section (abfd, sect, &dof))
|
2015-02-17 16:03:22 +01:00
|
|
|
complaint (&symfile_complaints,
|
|
|
|
_("could not obtain the contents of"
|
|
|
|
"section '%s' in objfile `%s'."),
|
|
|
|
sect->name, abfd->filename);
|
|
|
|
|
2015-02-19 23:42:37 +01:00
|
|
|
dtrace_process_dof (sect, objfile, probesp,
|
|
|
|
(struct dtrace_dof_hdr *) dof);
|
2015-02-17 16:03:22 +01:00
|
|
|
xfree (dof);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Helper function to determine whether a given probe is "enabled" or
|
|
|
|
"disabled". A disabled probe is a probe in which one or more
|
|
|
|
enablers are disabled. */
|
|
|
|
|
|
|
|
static int
|
|
|
|
dtrace_probe_is_enabled (struct dtrace_probe *probe)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct gdbarch *gdbarch = probe->p.arch;
|
|
|
|
struct dtrace_probe_enabler *enabler;
|
|
|
|
|
|
|
|
for (i = 0;
|
|
|
|
VEC_iterate (dtrace_probe_enabler_s, probe->enablers, i, enabler);
|
|
|
|
i++)
|
|
|
|
if (!gdbarch_dtrace_probe_is_enabled (gdbarch, enabler->address))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Implementation of the get_probe_address method. */
|
|
|
|
|
|
|
|
static CORE_ADDR
|
|
|
|
dtrace_get_probe_address (struct probe *probe, struct objfile *objfile)
|
|
|
|
{
|
|
|
|
gdb_assert (probe->pops == &dtrace_probe_ops);
|
|
|
|
return probe->address + ANOFFSET (objfile->section_offsets,
|
|
|
|
SECT_OFF_DATA (objfile));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Implementation of the get_probe_argument_count method. */
|
|
|
|
|
|
|
|
static unsigned
|
|
|
|
dtrace_get_probe_argument_count (struct probe *probe_generic,
|
|
|
|
struct frame_info *frame)
|
|
|
|
{
|
|
|
|
struct dtrace_probe *dtrace_probe = (struct dtrace_probe *) probe_generic;
|
|
|
|
|
|
|
|
gdb_assert (probe_generic->pops == &dtrace_probe_ops);
|
|
|
|
|
|
|
|
return dtrace_probe->probe_argc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Implementation of the can_evaluate_probe_arguments method. */
|
|
|
|
|
|
|
|
static int
|
|
|
|
dtrace_can_evaluate_probe_arguments (struct probe *probe_generic)
|
|
|
|
{
|
|
|
|
struct gdbarch *gdbarch = probe_generic->arch;
|
|
|
|
|
|
|
|
gdb_assert (probe_generic->pops == &dtrace_probe_ops);
|
|
|
|
return gdbarch_dtrace_parse_probe_argument_p (gdbarch);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Implementation of the evaluate_probe_argument method. */
|
|
|
|
|
|
|
|
static struct value *
|
|
|
|
dtrace_evaluate_probe_argument (struct probe *probe_generic, unsigned n,
|
|
|
|
struct frame_info *frame)
|
|
|
|
{
|
|
|
|
struct gdbarch *gdbarch = probe_generic->arch;
|
|
|
|
struct dtrace_probe *dtrace_probe = (struct dtrace_probe *) probe_generic;
|
|
|
|
struct dtrace_probe_arg *arg;
|
|
|
|
int pos = 0;
|
|
|
|
|
|
|
|
gdb_assert (probe_generic->pops == &dtrace_probe_ops);
|
|
|
|
|
|
|
|
arg = dtrace_get_arg (dtrace_probe, n, gdbarch);
|
|
|
|
return evaluate_subexp_standard (arg->type, arg->expr, &pos, EVAL_NORMAL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Implementation of the compile_to_ax method. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
dtrace_compile_to_ax (struct probe *probe_generic, struct agent_expr *expr,
|
|
|
|
struct axs_value *value, unsigned n)
|
|
|
|
{
|
|
|
|
struct dtrace_probe *dtrace_probe = (struct dtrace_probe *) probe_generic;
|
|
|
|
struct dtrace_probe_arg *arg;
|
|
|
|
union exp_element *pc;
|
|
|
|
|
|
|
|
gdb_assert (probe_generic->pops == &dtrace_probe_ops);
|
|
|
|
|
|
|
|
arg = dtrace_get_arg (dtrace_probe, n, expr->gdbarch);
|
|
|
|
|
|
|
|
pc = arg->expr->elts;
|
|
|
|
gen_expr (arg->expr, &pc, expr, value);
|
|
|
|
|
|
|
|
require_rvalue (expr, value);
|
|
|
|
value->type = arg->type;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Implementation of the probe_destroy method. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
dtrace_probe_destroy (struct probe *probe_generic)
|
|
|
|
{
|
|
|
|
struct dtrace_probe *probe = (struct dtrace_probe *) probe_generic;
|
|
|
|
struct dtrace_probe_arg *arg;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
gdb_assert (probe_generic->pops == &dtrace_probe_ops);
|
|
|
|
|
|
|
|
for (i = 0; VEC_iterate (dtrace_probe_arg_s, probe->args, i, arg); i++)
|
|
|
|
{
|
|
|
|
xfree (arg->type_str);
|
|
|
|
xfree (arg->expr);
|
|
|
|
}
|
|
|
|
|
|
|
|
VEC_free (dtrace_probe_enabler_s, probe->enablers);
|
|
|
|
VEC_free (dtrace_probe_arg_s, probe->args);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Implementation of the type_name method. */
|
|
|
|
|
|
|
|
static const char *
|
|
|
|
dtrace_type_name (struct probe *probe_generic)
|
|
|
|
{
|
|
|
|
gdb_assert (probe_generic->pops == &dtrace_probe_ops);
|
|
|
|
return "dtrace";
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Implementation of the gen_info_probes_table_header method. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
dtrace_gen_info_probes_table_header (VEC (info_probe_column_s) **heads)
|
|
|
|
{
|
|
|
|
info_probe_column_s dtrace_probe_column;
|
|
|
|
|
|
|
|
dtrace_probe_column.field_name = "enabled";
|
|
|
|
dtrace_probe_column.print_name = _("Enabled");
|
|
|
|
|
|
|
|
VEC_safe_push (info_probe_column_s, *heads, &dtrace_probe_column);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Implementation of the gen_info_probes_table_values method. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
dtrace_gen_info_probes_table_values (struct probe *probe_generic,
|
|
|
|
VEC (const_char_ptr) **ret)
|
|
|
|
{
|
|
|
|
struct dtrace_probe *probe = (struct dtrace_probe *) probe_generic;
|
|
|
|
const char *val = NULL;
|
|
|
|
|
|
|
|
gdb_assert (probe_generic->pops == &dtrace_probe_ops);
|
|
|
|
|
|
|
|
if (VEC_empty (dtrace_probe_enabler_s, probe->enablers))
|
|
|
|
val = "always";
|
|
|
|
else if (!gdbarch_dtrace_probe_is_enabled_p (probe_generic->arch))
|
|
|
|
val = "unknown";
|
|
|
|
else if (dtrace_probe_is_enabled (probe))
|
|
|
|
val = "yes";
|
|
|
|
else
|
|
|
|
val = "no";
|
|
|
|
|
|
|
|
VEC_safe_push (const_char_ptr, *ret, val);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Implementation of the enable_probe method. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
dtrace_enable_probe (struct probe *probe)
|
|
|
|
{
|
|
|
|
struct gdbarch *gdbarch = probe->arch;
|
|
|
|
struct dtrace_probe *dtrace_probe = (struct dtrace_probe *) probe;
|
|
|
|
struct dtrace_probe_enabler *enabler;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
gdb_assert (probe->pops == &dtrace_probe_ops);
|
|
|
|
|
|
|
|
/* Enabling a dtrace probe implies patching the text section of the
|
|
|
|
running process, so make sure the inferior is indeed running. */
|
|
|
|
if (ptid_equal (inferior_ptid, null_ptid))
|
|
|
|
error (_("No inferior running"));
|
|
|
|
|
|
|
|
/* Fast path. */
|
|
|
|
if (dtrace_probe_is_enabled (dtrace_probe))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Iterate over all defined enabler in the given probe and enable
|
|
|
|
them all using the corresponding gdbarch hook. */
|
|
|
|
|
|
|
|
for (i = 0;
|
|
|
|
VEC_iterate (dtrace_probe_enabler_s, dtrace_probe->enablers, i, enabler);
|
|
|
|
i++)
|
|
|
|
if (gdbarch_dtrace_enable_probe_p (gdbarch))
|
|
|
|
gdbarch_dtrace_enable_probe (gdbarch, enabler->address);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Implementation of the disable_probe method. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
dtrace_disable_probe (struct probe *probe)
|
|
|
|
{
|
|
|
|
struct gdbarch *gdbarch = probe->arch;
|
|
|
|
struct dtrace_probe *dtrace_probe = (struct dtrace_probe *) probe;
|
|
|
|
struct dtrace_probe_enabler *enabler;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
gdb_assert (probe->pops == &dtrace_probe_ops);
|
|
|
|
|
|
|
|
/* Disabling a dtrace probe implies patching the text section of the
|
|
|
|
running process, so make sure the inferior is indeed running. */
|
|
|
|
if (ptid_equal (inferior_ptid, null_ptid))
|
|
|
|
error (_("No inferior running"));
|
|
|
|
|
|
|
|
/* Fast path. */
|
|
|
|
if (!dtrace_probe_is_enabled (dtrace_probe))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Are we trying to disable a probe that does not have any enabler
|
|
|
|
associated? */
|
|
|
|
if (VEC_empty (dtrace_probe_enabler_s, dtrace_probe->enablers))
|
|
|
|
error (_("Probe %s:%s cannot be disabled: no enablers."), probe->provider, probe->name);
|
|
|
|
|
|
|
|
/* Iterate over all defined enabler in the given probe and disable
|
|
|
|
them all using the corresponding gdbarch hook. */
|
|
|
|
|
|
|
|
for (i = 0;
|
|
|
|
VEC_iterate (dtrace_probe_enabler_s, dtrace_probe->enablers, i, enabler);
|
|
|
|
i++)
|
|
|
|
if (gdbarch_dtrace_disable_probe_p (gdbarch))
|
|
|
|
gdbarch_dtrace_disable_probe (gdbarch, enabler->address);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* DTrace probe_ops. */
|
|
|
|
|
2015-02-26 15:03:47 +01:00
|
|
|
const struct probe_ops dtrace_probe_ops =
|
2015-02-17 16:03:22 +01:00
|
|
|
{
|
|
|
|
dtrace_probe_is_linespec,
|
|
|
|
dtrace_get_probes,
|
|
|
|
dtrace_get_probe_address,
|
|
|
|
dtrace_get_probe_argument_count,
|
|
|
|
dtrace_can_evaluate_probe_arguments,
|
|
|
|
dtrace_evaluate_probe_argument,
|
|
|
|
dtrace_compile_to_ax,
|
|
|
|
NULL, /* set_semaphore */
|
|
|
|
NULL, /* clear_semaphore */
|
|
|
|
dtrace_probe_destroy,
|
|
|
|
dtrace_type_name,
|
|
|
|
dtrace_gen_info_probes_table_header,
|
|
|
|
dtrace_gen_info_probes_table_values,
|
|
|
|
dtrace_enable_probe,
|
|
|
|
dtrace_disable_probe
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Implementation of the `info probes dtrace' command. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
info_probes_dtrace_command (char *arg, int from_tty)
|
|
|
|
{
|
|
|
|
info_probes_for_ops (arg, from_tty, &dtrace_probe_ops);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
_initialize_dtrace_probe (void)
|
|
|
|
{
|
|
|
|
VEC_safe_push (probe_ops_cp, all_probe_ops, &dtrace_probe_ops);
|
|
|
|
|
|
|
|
add_cmd ("dtrace", class_info, info_probes_dtrace_command,
|
|
|
|
_("\
|
|
|
|
Show information about DTrace static probes.\n\
|
|
|
|
Usage: info probes dtrace [PROVIDER [NAME [OBJECT]]]\n\
|
|
|
|
Each argument is a regular expression, used to select probes.\n\
|
|
|
|
PROVIDER matches probe provider names.\n\
|
|
|
|
NAME matches the probe names.\n\
|
|
|
|
OBJECT matches the executable or shared library name."),
|
|
|
|
info_probes_cmdlist_get ());
|
|
|
|
}
|