gdb/dtrace-probe.c

   1 /* DTrace probe support for GDB.
   2
   3    Copyright (C) 2014-2015 Free Software Foundation, Inc.
   4
   5    Contributed by Oracle, Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "probe.h"
  24 #include "vec.h"
  25 #include "elf-bfd.h"
  26 #include "gdbtypes.h"
  27 #include "obstack.h"
  28 #include "objfiles.h"
  29 #include "complaints.h"
  30 #include "value.h"
  31 #include "ax.h"
  32 #include "ax-gdb.h"
  33 #include "language.h"
  34 #include "parser-defs.h"
  35 #include "inferior.h"
  36
  37 /* The type of the ELF sections where we will find the DOF programs
  38    with information about probes.  */
  39
  40 #ifndef SHT_SUNW_dof
  41 # define SHT_SUNW_dof   0x6ffffff4
  42 #endif
  43
  44 /* Forward declaration.  */
  45
  46 extern const struct probe_ops dtrace_probe_ops;
  47
  48 /* The following structure represents a single argument for the
  49    probe.  */
  50
  51 struct dtrace_probe_arg
  52 {
  53   /* The type of the probe argument.  */
  54   struct type *type;
  55
  56   /* A string describing the type.  */
  57   char *type_str;
  58
  59   /* The argument converted to an internal GDB expression.  */
  60   struct expression *expr;
  61 };
  62
  63 typedef struct dtrace_probe_arg dtrace_probe_arg_s;
  64 DEF_VEC_O (dtrace_probe_arg_s);
  65
  66 /* The following structure represents an enabler for a probe.  */
  67
  68 struct dtrace_probe_enabler
  69 {
  70   /* Program counter where the is-enabled probe is installed.  The
  71      contents (nops, whatever...) stored at this address are
  72      architecture dependent.  */
  73   CORE_ADDR address;
  74 };
  75
  76 typedef struct dtrace_probe_enabler dtrace_probe_enabler_s;
  77 DEF_VEC_O (dtrace_probe_enabler_s);
  78
  79 /* The following structure represents a dtrace probe.  */
  80
  81 struct dtrace_probe
  82 {
  83   /* Generic information about the probe.  This must be the first
  84      element of this struct, in order to maintain binary compatibility
  85      with the `struct probe' and be able to fully abstract it.  */
  86   struct probe p;
  87
  88   /* A probe can have zero or more arguments.  */
  89   int probe_argc;
  90   VEC (dtrace_probe_arg_s) *args;
  91
  92   /* A probe can have zero or more "enablers" associated with it.  */
  93   VEC (dtrace_probe_enabler_s) *enablers;
  94
  95   /* Whether the expressions for the arguments have been built.  */
  96   unsigned int args_expr_built : 1;
  97 };
  98
  99 /* Implementation of the probe_is_linespec method.  */
 100
 101 static int
 102 dtrace_probe_is_linespec (const char **linespecp)
 103 {
 104   static const char *const keywords[] = { "-pdtrace", "-probe-dtrace", NULL };
 105
 106   return probe_is_linespec_by_keyword (linespecp, keywords);
 107 }
 108
 109 /* DOF programs can contain an arbitrary number of sections of 26
 110    different types.  In order to support DTrace USDT probes we only
 111    need to handle a subset of these section types, fortunately.  These
 112    section types are defined in the following enumeration.
 113
 114    See linux/dtrace/dof_defines.h for a complete list of section types
 115    along with their values.  */
 116
 117 enum dtrace_dof_sect_type
 118 {
 119   /* Null section.  */
 120   DTRACE_DOF_SECT_TYPE_NONE = 0,
 121   /* A dof_ecbdesc_t. */
 122   DTRACE_DOF_SECT_TYPE_ECBDESC = 3,
 123   /* A string table.  */
 124   DTRACE_DOF_SECT_TYPE_STRTAB = 8,
 125   /* A dof_provider_t  */
 126   DTRACE_DOF_SECT_TYPE_PROVIDER = 15,
 127   /* Array of dof_probe_t  */
 128   DTRACE_DOF_SECT_TYPE_PROBES = 16,
 129   /* An array of probe arg mappings.  */
 130   DTRACE_DOF_SECT_TYPE_PRARGS = 17,
 131   /* An array of probe arg offsets.  */
 132   DTRACE_DOF_SECT_TYPE_PROFFS = 18,
 133   /* An array of probe is-enabled offsets.  */
 134   DTRACE_DOF_SECT_TYPE_PRENOFFS = 26
 135 };
 136
 137 /* The following collection of data structures map the structure of
 138    DOF entities.  Again, we only cover the subset of DOF used to
 139    implement USDT probes.
 140
 141    See linux/dtrace/dof.h header for a complete list of data
 142    structures.  */
 143
 144 /* Offsets to index the dofh_ident[] array defined below.  */
 145
 146 enum dtrace_dof_ident
 147 {
 148   /* First byte of the magic number.  */
 149   DTRACE_DOF_ID_MAG0 = 0,
 150   /* Second byte of the magic number.  */
 151   DTRACE_DOF_ID_MAG1 = 1,
 152   /* Third byte of the magic number.  */
 153   DTRACE_DOF_ID_MAG2 = 2,
 154   /* Fourth byte of the magic number.  */
 155   DTRACE_DOF_ID_MAG3 = 3,
 156   /* An enum_dof_encoding value.  */
 157   DTRACE_DOF_ID_ENCODING = 5
 158 };
 159
 160 /* Possible values for dofh_ident[DOF_ID_ENCODING].  */
 161
 162 enum dtrace_dof_encoding
 163 {
 164   /* The DOF program is little-endian.  */
 165   DTRACE_DOF_ENCODE_LSB = 1,
 166   /* The DOF program is big-endian.  */
 167   DTRACE_DOF_ENCODE_MSB = 2
 168 };
 169
 170 /* A DOF header, which describes the contents of a DOF program: number
 171    of sections, size, etc.  */
 172
 173 struct dtrace_dof_hdr
 174 {
 175   /* Identification bytes (see above). */
 176   uint8_t dofh_ident[16];
 177   /* File attribute flags (if any). */
 178   uint32_t dofh_flags;
 179   /* Size of file header in bytes. */
 180   uint32_t dofh_hdrsize;
 181   /* Size of section header in bytes. */
 182   uint32_t dofh_secsize;
 183   /* Number of section headers. */
 184   uint32_t dofh_secnum;
 185   /* File offset of section headers. */
 186   uint64_t dofh_secoff;
 187   /* File size of loadable portion. */
 188   uint64_t dofh_loadsz;
 189   /* File size of entire DOF file. */
 190   uint64_t dofh_filesz;
 191   /* Reserved for future use. */
 192   uint64_t dofh_pad;
 193 };
 194
 195 /* A DOF section, whose contents depend on its type.  The several
 196    supported section types are described in the enum
 197    dtrace_dof_sect_type above.  */
 198
 199 struct dtrace_dof_sect
 200 {
 201   /* Section type (see the define above). */
 202   uint32_t dofs_type;
 203   /* Section data memory alignment. */
 204   uint32_t dofs_align;
 205   /* Section flags (if any). */
 206   uint32_t dofs_flags;
 207   /* Size of section entry (if table). */
 208   uint32_t dofs_entsize;
 209   /* DOF + offset points to the section data. */
 210   uint64_t dofs_offset;
 211   /* Size of section data in bytes.  */
 212   uint64_t dofs_size;
 213 };
 214
 215 /* A DOF provider, which is the provider of a probe.  */
 216
 217 struct dtrace_dof_provider
 218 {
 219   /* Link to a DTRACE_DOF_SECT_TYPE_STRTAB section. */
 220   uint32_t dofpv_strtab;
 221   /* Link to a DTRACE_DOF_SECT_TYPE_PROBES section. */
 222   uint32_t dofpv_probes;
 223   /* Link to a DTRACE_DOF_SECT_TYPE_PRARGS section. */
 224   uint32_t dofpv_prargs;
 225   /* Link to a DTRACE_DOF_SECT_TYPE_PROFFS section. */
 226   uint32_t dofpv_proffs;
 227   /* Provider name string. */
 228   uint32_t dofpv_name;
 229   /* Provider attributes. */
 230   uint32_t dofpv_provattr;
 231   /* Module attributes. */
 232   uint32_t dofpv_modattr;
 233   /* Function attributes. */
 234   uint32_t dofpv_funcattr;
 235   /* Name attributes. */
 236   uint32_t dofpv_nameattr;
 237   /* Args attributes. */
 238   uint32_t dofpv_argsattr;
 239   /* Link to a DTRACE_DOF_SECT_PRENOFFS section. */
 240   uint32_t dofpv_prenoffs;
 241 };
 242
 243 /* A set of DOF probes and is-enabled probes sharing a base address
 244    and several attributes.  The particular locations and attributes of
 245    each probe are maintained in arrays in several other DOF sections.
 246    See the comment in dtrace_process_dof_probe for details on how
 247    these attributes are stored.  */
 248
 249 struct dtrace_dof_probe
 250 {
 251   /* Probe base address or offset. */
 252   uint64_t dofpr_addr;
 253   /* Probe function string. */
 254   uint32_t dofpr_func;
 255   /* Probe name string. */
 256   uint32_t dofpr_name;
 257   /* Native argument type strings. */
 258   uint32_t dofpr_nargv;
 259   /* Translated argument type strings. */
 260   uint32_t dofpr_xargv;
 261   /* Index of first argument mapping. */
 262   uint32_t dofpr_argidx;
 263   /* Index of first offset entry. */
 264   uint32_t dofpr_offidx;
 265   /* Native argument count. */
 266   uint8_t  dofpr_nargc;
 267   /* Translated argument count. */
 268   uint8_t  dofpr_xargc;
 269   /* Number of offset entries for probe. */
 270   uint16_t dofpr_noffs;
 271   /* Index of first is-enabled offset. */
 272   uint32_t dofpr_enoffidx;
 273   /* Number of is-enabled offsets. */
 274   uint16_t dofpr_nenoffs;
 275   /* Reserved for future use. */
 276   uint16_t dofpr_pad1;
 277   /* Reserved for future use. */
 278   uint32_t dofpr_pad2;
 279 };
 280
 281 /* DOF supports two different encodings: MSB (big-endian) and LSB
 282    (little-endian).  The encoding is itself encoded in the DOF header.
 283    The following function returns an unsigned value in the host
 284    endianness.  */
 285
 286 #define DOF_UINT(dof, field)                                            \
 287   extract_unsigned_integer ((gdb_byte *) &(field),                      \
 288                             sizeof ((field)),                           \
 289                             (((dof)->dofh_ident[DTRACE_DOF_ID_ENCODING] \
 290                               == DTRACE_DOF_ENCODE_MSB)                 \
 291                              ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE))
 292
 293 /* The following macro applies a given byte offset to a DOF (a pointer
 294    to a dtrace_dof_hdr structure) and returns the resulting
 295    address.  */
 296
 297 #define DTRACE_DOF_PTR(dof, offset) (&((char *) (dof))[(offset)])
 298
 299 /* The following macro returns a pointer to the beginning of a given
 300    section in a DOF object.  The section is referred to by its index
 301    in the sections array.  */
 302
 303 #define DTRACE_DOF_SECT(dof, idx)                                       \
 304   ((struct dtrace_dof_sect *)                                           \
 305    DTRACE_DOF_PTR ((dof),                                               \
 306                    DOF_UINT ((dof), (dof)->dofh_secoff)                 \
 307                    + ((idx) * DOF_UINT ((dof), (dof)->dofh_secsize))))
 308
 309 /* Helper function to examine the probe described by the given PROBE
 310    and PROVIDER data structures and add it to the PROBESP vector.
 311    STRTAB, OFFTAB, EOFFTAB and ARGTAB are pointers to tables in the
 312    DOF program containing the attributes for the probe.  */
 313
 314 static void
 315 dtrace_process_dof_probe (struct objfile *objfile,
 316                           struct gdbarch *gdbarch, VEC (probe_p) **probesp,
 317                           struct dtrace_dof_hdr *dof,
 318                           struct dtrace_dof_probe *probe,
 319                           struct dtrace_dof_provider *provider,
 320                           char *strtab, char *offtab, char *eofftab,
 321                           char *argtab, uint64_t strtab_size)
 322 {
 323   int i, j, num_probes, num_enablers;
 324   struct cleanup *cleanup;
 325   VEC (dtrace_probe_enabler_s) *enablers;
 326   char *p;
 327
 328   /* Each probe section can define zero or more probes of two
 329      different types:
 330
 331      - probe->dofpr_noffs regular probes whose program counters are
 332        stored in 32bit words starting at probe->dofpr_addr +
 333        offtab[probe->dofpr_offidx].
 334
 335      - probe->dofpr_nenoffs is-enabled probes whose program counters
 336        are stored in 32bit words starting at probe->dofpr_addr +
 337        eofftab[probe->dofpr_enoffidx].
 338
 339      However is-enabled probes are not probes per-se, but an
 340      optimization hack that is implemented in the kernel in a very
 341      similar way than normal probes.  This is how we support
 342      is-enabled probes on GDB:
 343
 344      - Our probes are always DTrace regular probes.
 345
 346      - Our probes can be associated with zero or more "enablers".  The
 347        list of enablers is built from the is-enabled probes defined in
 348        the Probe section.
 349
 350      - Probes having a non-empty list of enablers can be enabled or
 351        disabled using the `enable probe' and `disable probe' commands
 352        respectively.  The `Enabled' column in the output of `info
 353        probes' will read `yes' if the enablers are activated, `no'
 354        otherwise.
 355
 356      - Probes having an empty list of enablers are always enabled.
 357        The `Enabled' column in the output of `info probes' will
 358        read `always'.
 359
 360      It follows that if there are DTrace is-enabled probes defined for
 361      some provider/name but no DTrace regular probes defined then the
 362      GDB user wont be able to enable/disable these conditionals.  */
 363
 364   num_probes = DOF_UINT (dof, probe->dofpr_noffs);
 365   if (num_probes == 0)
 366     return;
 367
 368   /* Build the list of enablers for the probes defined in this Probe
 369      DOF section.  */
 370   enablers = NULL;
 371   cleanup
 372     = make_cleanup (VEC_cleanup (dtrace_probe_enabler_s), &enablers);
 373   num_enablers = DOF_UINT (dof, probe->dofpr_nenoffs);
 374   for (i = 0; i < num_enablers; i++)
 375     {
 376       struct dtrace_probe_enabler enabler;
 377       uint32_t enabler_offset
 378         = ((uint32_t *) eofftab)[DOF_UINT (dof, probe->dofpr_enoffidx) + i];
 379
 380       enabler.address = DOF_UINT (dof, probe->dofpr_addr)
 381         + DOF_UINT (dof, enabler_offset);
 382       VEC_safe_push (dtrace_probe_enabler_s, enablers, &enabler);
 383     }
 384
 385   for (i = 0; i < num_probes; i++)
 386     {
 387       uint32_t probe_offset
 388         = ((uint32_t *) offtab)[DOF_UINT (dof, probe->dofpr_offidx) + i];
 389       struct dtrace_probe *ret
 390         = obstack_alloc (&objfile->per_bfd->storage_obstack, sizeof (*ret));
 391
 392       ret->p.pops = &dtrace_probe_ops;
 393       ret->p.arch = gdbarch;
 394       ret->args_expr_built = 0;
 395
 396       /* Set the provider and the name of the probe.  */
 397       ret->p.provider
 398         = xstrdup (strtab + DOF_UINT (dof, provider->dofpv_name));
 399       ret->p.name = xstrdup (strtab + DOF_UINT (dof, probe->dofpr_name));
 400
 401       /* The probe address.  */
 402       ret->p.address
 403         = DOF_UINT (dof, probe->dofpr_addr) + DOF_UINT (dof, probe_offset);
 404
 405       /* Number of arguments in the probe.  */
 406       ret->probe_argc = DOF_UINT (dof, probe->dofpr_nargc);
 407
 408       /* Store argument type descriptions.  A description of the type
 409          of the argument is in the (J+1)th null-terminated string
 410          starting at 'strtab' + 'probe->dofpr_nargv'.  */
 411       ret->args = NULL;
 412       p = strtab + DOF_UINT (dof, probe->dofpr_nargv);
 413       for (j = 0; j < ret->probe_argc; j++)
 414         {
 415           struct dtrace_probe_arg arg;
 416           struct expression *expr = NULL;
 417
 418           /* Set arg.expr to ensure all fields in expr are initialized and
 419              the compiler will not warn when arg is used.  */
 420           arg.expr = NULL;
 421           arg.type_str = xstrdup (p);
 422
 423           /* Use strtab_size as a sentinel.  */
 424           while (*p++ != '\0' && p - strtab < strtab_size);
 425
 426           /* Try to parse a type expression from the type string.  If
 427              this does not work then we set the type to `long
 428              int'.  */
 429           arg.type = builtin_type (gdbarch)->builtin_long;
 430
 431           TRY
 432             {
 433               expr = parse_expression_with_language (arg.type_str, language_c);
 434             }
 435           CATCH (ex, RETURN_MASK_ERROR)
 436             {
 437               expr = NULL;
 438             }
 439           END_CATCH
 440
 441           if (expr != NULL && expr->elts[0].opcode == OP_TYPE)
 442             arg.type = expr->elts[1].type;
 443
 444           VEC_safe_push (dtrace_probe_arg_s, ret->args, &arg);
 445         }
 446
 447       /* Add the vector of enablers to this probe, if any.  */
 448       ret->enablers = VEC_copy (dtrace_probe_enabler_s, enablers);
 449
 450       /* Successfully created probe.  */
 451       VEC_safe_push (probe_p, *probesp, (struct probe *) ret);
 452     }
 453
 454   do_cleanups (cleanup);
 455 }
 456
 457 /* Helper function to collect the probes described in the DOF program
 458    whose header is pointed by DOF and add them to the PROBESP vector.
 459    SECT is the ELF section containing the DOF program and OBJFILE is
 460    its containing object file.  */
 461
 462 static void
 463 dtrace_process_dof (asection *sect, struct objfile *objfile,
 464                     VEC (probe_p) **probesp, struct dtrace_dof_hdr *dof)
 465 {
 466   bfd *abfd = objfile->obfd;
 467   int size = bfd_get_arch_size (abfd) / 8;
 468   struct gdbarch *gdbarch = get_objfile_arch (objfile);
 469   struct dtrace_dof_sect *section;
 470   int i;
 471
 472   /* The first step is to check for the DOF magic number.  If no valid
 473      DOF data is found in the section then a complaint is issued to
 474      the user and the section skipped.  */
 475   if (dof->dofh_ident[DTRACE_DOF_ID_MAG0] != 0x7F
 476       || dof->dofh_ident[DTRACE_DOF_ID_MAG1] != 'D'
 477       || dof->dofh_ident[DTRACE_DOF_ID_MAG2] != 'O'
 478       || dof->dofh_ident[DTRACE_DOF_ID_MAG3] != 'F')
 479     goto invalid_dof_data;
 480
 481   /* Make sure the encoding mark is either DTRACE_DOF_ENCODE_LSB or
 482      DTRACE_DOF_ENCODE_MSB.  */
 483   if (dof->dofh_ident[DTRACE_DOF_ID_ENCODING] != DTRACE_DOF_ENCODE_LSB
 484       && dof->dofh_ident[DTRACE_DOF_ID_ENCODING] != DTRACE_DOF_ENCODE_MSB)
 485     goto invalid_dof_data;
 486
 487   /* Make sure this DOF is not an enabling DOF, i.e. there are no ECB
 488      Description sections.  */
 489   section = (struct dtrace_dof_sect *) DTRACE_DOF_PTR (dof,
 490                                                        DOF_UINT (dof, dof->dofh_secoff));
 491   for (i = 0; i < DOF_UINT (dof, dof->dofh_secnum); i++, section++)
 492     if (section->dofs_type == DTRACE_DOF_SECT_TYPE_ECBDESC)
 493       return;
 494
 495   /* Iterate over any section of type Provider and extract the probe
 496      information from them.  If there are no "provider" sections on
 497      the DOF then we just return.  */
 498   section = (struct dtrace_dof_sect *) DTRACE_DOF_PTR (dof,
 499                                                        DOF_UINT (dof, dof->dofh_secoff));
 500   for (i = 0; i < DOF_UINT (dof, dof->dofh_secnum); i++, section++)
 501     if (DOF_UINT (dof, section->dofs_type) == DTRACE_DOF_SECT_TYPE_PROVIDER)
 502       {
 503         struct dtrace_dof_provider *provider = (struct dtrace_dof_provider *)
 504           DTRACE_DOF_PTR (dof, DOF_UINT (dof, section->dofs_offset));
 505         struct dtrace_dof_sect *strtab_s
 506           = DTRACE_DOF_SECT (dof, DOF_UINT (dof, provider->dofpv_strtab));
 507         struct dtrace_dof_sect *probes_s
 508           = DTRACE_DOF_SECT (dof, DOF_UINT (dof, provider->dofpv_probes));
 509         struct dtrace_dof_sect *args_s
 510           = DTRACE_DOF_SECT (dof, DOF_UINT (dof, provider->dofpv_prargs));
 511         struct dtrace_dof_sect *offsets_s
 512           = DTRACE_DOF_SECT (dof, DOF_UINT (dof, provider->dofpv_proffs));
 513         struct dtrace_dof_sect *eoffsets_s
 514           = DTRACE_DOF_SECT (dof, DOF_UINT (dof, provider->dofpv_prenoffs));
 515         char *strtab  = DTRACE_DOF_PTR (dof, DOF_UINT (dof, strtab_s->dofs_offset));
 516         char *offtab  = DTRACE_DOF_PTR (dof, DOF_UINT (dof, offsets_s->dofs_offset));
 517         char *eofftab = DTRACE_DOF_PTR (dof, DOF_UINT (dof, eoffsets_s->dofs_offset));
 518         char *argtab  = DTRACE_DOF_PTR (dof, DOF_UINT (dof, args_s->dofs_offset));
 519         unsigned int entsize = DOF_UINT (dof, probes_s->dofs_entsize);
 520         int num_probes;
 521
 522         if (DOF_UINT (dof, section->dofs_size)
 523             < sizeof (struct dtrace_dof_provider))
 524           {
 525             /* The section is smaller than expected, so do not use it.
 526                This has been observed on x86-solaris 10.  */
 527             goto invalid_dof_data;
 528           }
 529
 530         /* Very, unlikely, but could crash gdb if not handled
 531            properly.  */
 532         if (entsize == 0)
 533           goto invalid_dof_data;
 534
 535         num_probes = DOF_UINT (dof, probes_s->dofs_size) / entsize;
 536
 537         for (i = 0; i < num_probes; i++)
 538           {
 539             struct dtrace_dof_probe *probe = (struct dtrace_dof_probe *)
 540               DTRACE_DOF_PTR (dof, DOF_UINT (dof, probes_s->dofs_offset)
 541                               + (i * DOF_UINT (dof, probes_s->dofs_entsize)));
 542
 543             dtrace_process_dof_probe (objfile,
 544                                       gdbarch, probesp,
 545                                       dof, probe,
 546                                       provider, strtab, offtab, eofftab, argtab,
 547                                       DOF_UINT (dof, strtab_s->dofs_size));
 548           }
 549       }
 550
 551   return;
 552
 553  invalid_dof_data:
 554   complaint (&symfile_complaints,
 555              _("skipping section '%s' which does not contain valid DOF data."),
 556              sect->name);
 557 }
 558
 559 /* Helper function to build the GDB internal expressiosn that, once
 560    evaluated, will calculate the values of the arguments of a given
 561    PROBE.  */
 562
 563 static void
 564 dtrace_build_arg_exprs (struct dtrace_probe *probe,
 565                         struct gdbarch *gdbarch)
 566 {
 567   struct parser_state pstate;
 568   struct dtrace_probe_arg *arg;
 569   int i;
 570
 571   probe->args_expr_built = 1;
 572
 573   /* Iterate over the arguments in the probe and build the
 574      corresponding GDB internal expression that will generate the
 575      value of the argument when executed at the PC of the probe.  */
 576   for (i = 0; i < probe->probe_argc; i++)
 577     {
 578       struct cleanup *back_to;
 579
 580       arg = VEC_index (dtrace_probe_arg_s, probe->args, i);
 581
 582       /* Initialize the expression buffer in the parser state.  The
 583          language does not matter, since we are using our own
 584          parser.  */
 585       initialize_expout (&pstate, 10, current_language, gdbarch);
 586       back_to = make_cleanup (free_current_contents, &pstate.expout);
 587
 588       /* The argument value, which is ABI dependent and casted to
 589          `long int'.  */
 590       gdbarch_dtrace_parse_probe_argument (gdbarch, &pstate, i);
 591
 592       discard_cleanups (back_to);
 593
 594       /* Casting to the expected type, but only if the type was
 595          recognized at probe load time.  Otherwise the argument will
 596          be evaluated as the long integer passed to the probe.  */
 597       if (arg->type != NULL)
 598         {
 599           write_exp_elt_opcode (&pstate, UNOP_CAST);
 600           write_exp_elt_type (&pstate, arg->type);
 601           write_exp_elt_opcode (&pstate, UNOP_CAST);
 602         }
 603
 604       reallocate_expout (&pstate);
 605       arg->expr = pstate.expout;
 606       prefixify_expression (arg->expr);
 607     }
 608 }
 609
 610 /* Helper function to return the Nth argument of a given PROBE.  */
 611
 612 static struct dtrace_probe_arg *
 613 dtrace_get_arg (struct dtrace_probe *probe, unsigned n,
 614                 struct gdbarch *gdbarch)
 615 {
 616   if (!probe->args_expr_built)
 617     dtrace_build_arg_exprs (probe, gdbarch);
 618
 619   return VEC_index (dtrace_probe_arg_s, probe->args, n);
 620 }
 621
 622 /* Implementation of the get_probes method.  */
 623
 624 static void
 625 dtrace_get_probes (VEC (probe_p) **probesp, struct objfile *objfile)
 626 {
 627   bfd *abfd = objfile->obfd;
 628   asection *sect = NULL;
 629
 630   /* Do nothing in case this is a .debug file, instead of the objfile
 631      itself.  */
 632   if (objfile->separate_debug_objfile_backlink != NULL)
 633     return;
 634
 635   /* Iterate over the sections in OBJFILE looking for DTrace
 636      information.  */
 637   for (sect = abfd->sections; sect != NULL; sect = sect->next)
 638     {
 639       if (elf_section_data (sect)->this_hdr.sh_type == SHT_SUNW_dof)
 640         {
 641           bfd_byte *dof;
 642
 643           /* Read the contents of the DOF section and then process it to
 644              extract the information of any probe defined into it.  */
 645           if (!bfd_malloc_and_get_section (abfd, sect, &dof))
 646             complaint (&symfile_complaints,
 647                        _("could not obtain the contents of"
 648                          "section '%s' in objfile `%s'."),
 649                        sect->name, abfd->filename);
 650
 651           dtrace_process_dof (sect, objfile, probesp,
 652                               (struct dtrace_dof_hdr *) dof);
 653           xfree (dof);
 654         }
 655     }
 656 }
 657
 658 /* Helper function to determine whether a given probe is "enabled" or
 659    "disabled".  A disabled probe is a probe in which one or more
 660    enablers are disabled.  */
 661
 662 static int
 663 dtrace_probe_is_enabled (struct dtrace_probe *probe)
 664 {
 665   int i;
 666   struct gdbarch *gdbarch = probe->p.arch;
 667   struct dtrace_probe_enabler *enabler;
 668
 669   for (i = 0;
 670        VEC_iterate (dtrace_probe_enabler_s, probe->enablers, i, enabler);
 671        i++)
 672     if (!gdbarch_dtrace_probe_is_enabled (gdbarch, enabler->address))
 673       return 0;
 674
 675   return 1;
 676 }
 677
 678 /* Implementation of the get_probe_address method.  */
 679
 680 static CORE_ADDR
 681 dtrace_get_probe_address (struct probe *probe, struct objfile *objfile)
 682 {
 683   gdb_assert (probe->pops == &dtrace_probe_ops);
 684   return probe->address + ANOFFSET (objfile->section_offsets,
 685                                     SECT_OFF_DATA (objfile));
 686 }
 687
 688 /* Implementation of the get_probe_argument_count method.  */
 689
 690 static unsigned
 691 dtrace_get_probe_argument_count (struct probe *probe_generic,
 692                                  struct frame_info *frame)
 693 {
 694   struct dtrace_probe *dtrace_probe = (struct dtrace_probe *) probe_generic;
 695
 696   gdb_assert (probe_generic->pops == &dtrace_probe_ops);
 697
 698   return dtrace_probe->probe_argc;
 699 }
 700
 701 /* Implementation of the can_evaluate_probe_arguments method.  */
 702
 703 static int
 704 dtrace_can_evaluate_probe_arguments (struct probe *probe_generic)
 705 {
 706   struct gdbarch *gdbarch = probe_generic->arch;
 707
 708   gdb_assert (probe_generic->pops == &dtrace_probe_ops);
 709   return gdbarch_dtrace_parse_probe_argument_p (gdbarch);
 710 }
 711
 712 /* Implementation of the evaluate_probe_argument method.  */
 713
 714 static struct value *
 715 dtrace_evaluate_probe_argument (struct probe *probe_generic, unsigned n,
 716                                 struct frame_info *frame)
 717 {
 718   struct gdbarch *gdbarch = probe_generic->arch;
 719   struct dtrace_probe *dtrace_probe = (struct dtrace_probe *) probe_generic;
 720   struct dtrace_probe_arg *arg;
 721   int pos = 0;
 722
 723   gdb_assert (probe_generic->pops == &dtrace_probe_ops);
 724
 725   arg = dtrace_get_arg (dtrace_probe, n, gdbarch);
 726   return evaluate_subexp_standard (arg->type, arg->expr, &pos, EVAL_NORMAL);
 727 }
 728
 729 /* Implementation of the compile_to_ax method.  */
 730
 731 static void
 732 dtrace_compile_to_ax (struct probe *probe_generic, struct agent_expr *expr,
 733                       struct axs_value *value, unsigned n)
 734 {
 735   struct dtrace_probe *dtrace_probe = (struct dtrace_probe *) probe_generic;
 736   struct dtrace_probe_arg *arg;
 737   union exp_element *pc;
 738
 739   gdb_assert (probe_generic->pops == &dtrace_probe_ops);
 740
 741   arg = dtrace_get_arg (dtrace_probe, n, expr->gdbarch);
 742
 743   pc = arg->expr->elts;
 744   gen_expr (arg->expr, &pc, expr, value);
 745
 746   require_rvalue (expr, value);
 747   value->type = arg->type;
 748 }
 749
 750 /* Implementation of the probe_destroy method.  */
 751
 752 static void
 753 dtrace_probe_destroy (struct probe *probe_generic)
 754 {
 755   struct dtrace_probe *probe = (struct dtrace_probe *) probe_generic;
 756   struct dtrace_probe_arg *arg;
 757   int i;
 758
 759   gdb_assert (probe_generic->pops == &dtrace_probe_ops);
 760
 761   for (i = 0; VEC_iterate (dtrace_probe_arg_s, probe->args, i, arg); i++)
 762     {
 763       xfree (arg->type_str);
 764       xfree (arg->expr);
 765     }
 766
 767   VEC_free (dtrace_probe_enabler_s, probe->enablers);
 768   VEC_free (dtrace_probe_arg_s, probe->args);
 769 }
 770
 771 /* Implementation of the type_name method.  */
 772
 773 static const char *
 774 dtrace_type_name (struct probe *probe_generic)
 775 {
 776   gdb_assert (probe_generic->pops == &dtrace_probe_ops);
 777   return "dtrace";
 778 }
 779
 780 /* Implementation of the gen_info_probes_table_header method.  */
 781
 782 static void
 783 dtrace_gen_info_probes_table_header (VEC (info_probe_column_s) **heads)
 784 {
 785   info_probe_column_s dtrace_probe_column;
 786
 787   dtrace_probe_column.field_name = "enabled";
 788   dtrace_probe_column.print_name = _("Enabled");
 789
 790   VEC_safe_push (info_probe_column_s, *heads, &dtrace_probe_column);
 791 }
 792
 793 /* Implementation of the gen_info_probes_table_values method.  */
 794
 795 static void
 796 dtrace_gen_info_probes_table_values (struct probe *probe_generic,
 797                                      VEC (const_char_ptr) **ret)
 798 {
 799   struct dtrace_probe *probe = (struct dtrace_probe *) probe_generic;
 800   const char *val = NULL;
 801
 802   gdb_assert (probe_generic->pops == &dtrace_probe_ops);
 803
 804   if (VEC_empty (dtrace_probe_enabler_s, probe->enablers))
 805     val = "always";
 806   else if (!gdbarch_dtrace_probe_is_enabled_p (probe_generic->arch))
 807     val = "unknown";
 808   else if (dtrace_probe_is_enabled (probe))
 809     val = "yes";
 810   else
 811     val = "no";
 812
 813   VEC_safe_push (const_char_ptr, *ret, val);
 814 }
 815
 816 /* Implementation of the enable_probe method.  */
 817
 818 static void
 819 dtrace_enable_probe (struct probe *probe)
 820 {
 821   struct gdbarch *gdbarch = probe->arch;
 822   struct dtrace_probe *dtrace_probe = (struct dtrace_probe *) probe;
 823   struct dtrace_probe_enabler *enabler;
 824   int i;
 825
 826   gdb_assert (probe->pops == &dtrace_probe_ops);
 827
 828   /* Enabling a dtrace probe implies patching the text section of the
 829      running process, so make sure the inferior is indeed running.  */
 830   if (ptid_equal (inferior_ptid, null_ptid))
 831     error (_("No inferior running"));
 832
 833   /* Fast path.  */
 834   if (dtrace_probe_is_enabled (dtrace_probe))
 835     return;
 836
 837   /* Iterate over all defined enabler in the given probe and enable
 838      them all using the corresponding gdbarch hook.  */
 839
 840   for (i = 0;
 841        VEC_iterate (dtrace_probe_enabler_s, dtrace_probe->enablers, i, enabler);
 842        i++)
 843     if (gdbarch_dtrace_enable_probe_p (gdbarch))
 844       gdbarch_dtrace_enable_probe (gdbarch, enabler->address);
 845 }
 846
 847
 848 /* Implementation of the disable_probe method.  */
 849
 850 static void
 851 dtrace_disable_probe (struct probe *probe)
 852 {
 853   struct gdbarch *gdbarch = probe->arch;
 854   struct dtrace_probe *dtrace_probe = (struct dtrace_probe *) probe;
 855   struct dtrace_probe_enabler *enabler;
 856   int i;
 857
 858   gdb_assert (probe->pops == &dtrace_probe_ops);
 859
 860   /* Disabling a dtrace probe implies patching the text section of the
 861      running process, so make sure the inferior is indeed running.  */
 862   if (ptid_equal (inferior_ptid, null_ptid))
 863     error (_("No inferior running"));
 864
 865   /* Fast path.  */
 866   if (!dtrace_probe_is_enabled (dtrace_probe))
 867     return;
 868
 869   /* Are we trying to disable a probe that does not have any enabler
 870      associated?  */
 871   if (VEC_empty (dtrace_probe_enabler_s, dtrace_probe->enablers))
 872     error (_("Probe %s:%s cannot be disabled: no enablers."), probe->provider, probe->name);
 873
 874   /* Iterate over all defined enabler in the given probe and disable
 875      them all using the corresponding gdbarch hook.  */
 876
 877   for (i = 0;
 878        VEC_iterate (dtrace_probe_enabler_s, dtrace_probe->enablers, i, enabler);
 879        i++)
 880     if (gdbarch_dtrace_disable_probe_p (gdbarch))
 881       gdbarch_dtrace_disable_probe (gdbarch, enabler->address);
 882 }
 883
 884 /* DTrace probe_ops.  */
 885
 886 const struct probe_ops dtrace_probe_ops =
 887 {
 888   dtrace_probe_is_linespec,
 889   dtrace_get_probes,
 890   dtrace_get_probe_address,
 891   dtrace_get_probe_argument_count,
 892   dtrace_can_evaluate_probe_arguments,
 893   dtrace_evaluate_probe_argument,
 894   dtrace_compile_to_ax,
 895   NULL, /* set_semaphore  */
 896   NULL, /* clear_semaphore  */
 897   dtrace_probe_destroy,
 898   dtrace_type_name,
 899   dtrace_gen_info_probes_table_header,
 900   dtrace_gen_info_probes_table_values,
 901   dtrace_enable_probe,
 902   dtrace_disable_probe
 903 };
 904
 905 /* Implementation of the `info probes dtrace' command.  */
 906
 907 static void
 908 info_probes_dtrace_command (char *arg, int from_tty)
 909 {
 910   info_probes_for_ops (arg, from_tty, &dtrace_probe_ops);
 911 }
 912
 913 void _initialize_dtrace_probe (void);
 914
 915 void
 916 _initialize_dtrace_probe (void)
 917 {
 918   VEC_safe_push (probe_ops_cp, all_probe_ops, &dtrace_probe_ops);
 919
 920   add_cmd ("dtrace", class_info, info_probes_dtrace_command,
 921            _("\
 922 Show information about DTrace static probes.\n\
 923 Usage: info probes dtrace [PROVIDER [NAME [OBJECT]]]\n\
 924 Each argument is a regular expression, used to select probes.\n\
 925 PROVIDER matches probe provider names.\n\
 926 NAME matches the probe names.\n\
 927 OBJECT matches the executable or shared library name."),
 928            info_probes_cmdlist_get ());
 929 }