gdb/stap-probe.c

   1 /* SystemTap probe support for GDB.
   2
   3    Copyright (C) 2012-2019 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "stap-probe.h"
  22 #include "probe.h"
  23 #include "gdbsupport/vec.h"
  24 #include "ui-out.h"
  25 #include "objfiles.h"
  26 #include "arch-utils.h"
  27 #include "command.h"
  28 #include "gdbcmd.h"
  29 #include "filenames.h"
  30 #include "value.h"
  31 #include "ax.h"
  32 #include "ax-gdb.h"
  33 #include "complaints.h"
  34 #include "cli/cli-utils.h"
  35 #include "linespec.h"
  36 #include "user-regs.h"
  37 #include "parser-defs.h"
  38 #include "language.h"
  39 #include "elf-bfd.h"
  40
  41 #include <ctype.h>
  42
  43 /* The name of the SystemTap section where we will find information about
  44    the probes.  */
  45
  46 #define STAP_BASE_SECTION_NAME ".stapsdt.base"
  47
  48 /* Should we display debug information for the probe's argument expression
  49    parsing?  */
  50
  51 static unsigned int stap_expression_debug = 0;
  52
  53 /* The various possibilities of bitness defined for a probe's argument.
  54
  55    The relationship is:
  56
  57    - STAP_ARG_BITNESS_UNDEFINED:  The user hasn't specified the bitness.
  58    - STAP_ARG_BITNESS_8BIT_UNSIGNED:  argument string starts with `1@'.
  59    - STAP_ARG_BITNESS_8BIT_SIGNED:  argument string starts with `-1@'.
  60    - STAP_ARG_BITNESS_16BIT_UNSIGNED:  argument string starts with `2@'.
  61    - STAP_ARG_BITNESS_16BIT_SIGNED:  argument string starts with `-2@'.
  62    - STAP_ARG_BITNESS_32BIT_UNSIGNED:  argument string starts with `4@'.
  63    - STAP_ARG_BITNESS_32BIT_SIGNED:  argument string starts with `-4@'.
  64    - STAP_ARG_BITNESS_64BIT_UNSIGNED:  argument string starts with `8@'.
  65    - STAP_ARG_BITNESS_64BIT_SIGNED:  argument string starts with `-8@'.  */
  66
  67 enum stap_arg_bitness
  68 {
  69   STAP_ARG_BITNESS_UNDEFINED,
  70   STAP_ARG_BITNESS_8BIT_UNSIGNED,
  71   STAP_ARG_BITNESS_8BIT_SIGNED,
  72   STAP_ARG_BITNESS_16BIT_UNSIGNED,
  73   STAP_ARG_BITNESS_16BIT_SIGNED,
  74   STAP_ARG_BITNESS_32BIT_UNSIGNED,
  75   STAP_ARG_BITNESS_32BIT_SIGNED,
  76   STAP_ARG_BITNESS_64BIT_UNSIGNED,
  77   STAP_ARG_BITNESS_64BIT_SIGNED,
  78 };
  79
  80 /* The following structure represents a single argument for the probe.  */
  81
  82 struct stap_probe_arg
  83 {
  84   /* Constructor for stap_probe_arg.  */
  85   stap_probe_arg (enum stap_arg_bitness bitness_, struct type *atype_,
  86                   expression_up &&aexpr_)
  87   : bitness (bitness_), atype (atype_), aexpr (std::move (aexpr_))
  88   {}
  89
  90   /* The bitness of this argument.  */
  91   enum stap_arg_bitness bitness;
  92
  93   /* The corresponding `struct type *' to the bitness.  */
  94   struct type *atype;
  95
  96   /* The argument converted to an internal GDB expression.  */
  97   expression_up aexpr;
  98 };
  99
 100 /* Class that implements the static probe methods for "stap" probes.  */
 101
 102 class stap_static_probe_ops : public static_probe_ops
 103 {
 104 public:
 105   /* See probe.h.  */
 106   bool is_linespec (const char **linespecp) const override;
 107
 108   /* See probe.h.  */
 109   void get_probes (std::vector<std::unique_ptr<probe>> *probesp,
 110                    struct objfile *objfile) const override;
 111
 112   /* See probe.h.  */
 113   const char *type_name () const override;
 114
 115   /* See probe.h.  */
 116   std::vector<struct info_probe_column> gen_info_probes_table_header
 117     () const override;
 118 };
 119
 120 /* SystemTap static_probe_ops.  */
 121
 122 const stap_static_probe_ops stap_static_probe_ops {};
 123
 124 class stap_probe : public probe
 125 {
 126 public:
 127   /* Constructor for stap_probe.  */
 128   stap_probe (std::string &&name_, std::string &&provider_, CORE_ADDR address_,
 129               struct gdbarch *arch_, CORE_ADDR sem_addr, const char *args_text)
 130     : probe (std::move (name_), std::move (provider_), address_, arch_),
 131       m_sem_addr (sem_addr),
 132       m_have_parsed_args (false), m_unparsed_args_text (args_text)
 133   {}
 134
 135   /* See probe.h.  */
 136   CORE_ADDR get_relocated_address (struct objfile *objfile) override;
 137
 138   /* See probe.h.  */
 139   unsigned get_argument_count (struct frame_info *frame) override;
 140
 141   /* See probe.h.  */
 142   bool can_evaluate_arguments () const override;
 143
 144   /* See probe.h.  */
 145   struct value *evaluate_argument (unsigned n,
 146                                    struct frame_info *frame) override;
 147
 148   /* See probe.h.  */
 149   void compile_to_ax (struct agent_expr *aexpr,
 150                       struct axs_value *axs_value,
 151                       unsigned n) override;
 152
 153   /* See probe.h.  */
 154   void set_semaphore (struct objfile *objfile,
 155                       struct gdbarch *gdbarch) override;
 156
 157   /* See probe.h.  */
 158   void clear_semaphore (struct objfile *objfile,
 159                         struct gdbarch *gdbarch) override;
 160
 161   /* See probe.h.  */
 162   const static_probe_ops *get_static_ops () const override;
 163
 164   /* See probe.h.  */
 165   std::vector<const char *> gen_info_probes_table_values () const override;
 166
 167   /* Return argument N of probe.
 168
 169      If the probe's arguments have not been parsed yet, parse them.  If
 170      there are no arguments, throw an exception (error).  Otherwise,
 171      return the requested argument.  */
 172   struct stap_probe_arg *get_arg_by_number (unsigned n,
 173                                             struct gdbarch *gdbarch)
 174   {
 175     if (!m_have_parsed_args)
 176       this->parse_arguments (gdbarch);
 177
 178     gdb_assert (m_have_parsed_args);
 179     if (m_parsed_args.empty ())
 180       internal_error (__FILE__, __LINE__,
 181                       _("Probe '%s' apparently does not have arguments, but \n"
 182                         "GDB is requesting its argument number %u anyway.  "
 183                         "This should not happen.  Please report this bug."),
 184                       this->get_name ().c_str (), n);
 185
 186     if (n > m_parsed_args.size ())
 187       internal_error (__FILE__, __LINE__,
 188                       _("Probe '%s' has %d arguments, but GDB is requesting\n"
 189                         "argument %u.  This should not happen.  Please\n"
 190                         "report this bug."),
 191                       this->get_name ().c_str (),
 192                       (int) m_parsed_args.size (), n);
 193
 194     return &m_parsed_args[n];
 195   }
 196
 197   /* Function which parses an argument string from the probe,
 198      correctly splitting the arguments and storing their information
 199      in properly ways.
 200
 201      Consider the following argument string (x86 syntax):
 202
 203      `4@%eax 4@$10'
 204
 205      We have two arguments, `%eax' and `$10', both with 32-bit
 206      unsigned bitness.  This function basically handles them, properly
 207      filling some structures with this information.  */
 208   void parse_arguments (struct gdbarch *gdbarch);
 209
 210 private:
 211   /* If the probe has a semaphore associated, then this is the value of
 212      it, relative to SECT_OFF_DATA.  */
 213   CORE_ADDR m_sem_addr;
 214
 215   /* True if the arguments have been parsed.  */
 216   bool m_have_parsed_args;
 217
 218   /* The text version of the probe's arguments, unparsed.  */
 219   const char *m_unparsed_args_text;
 220
 221   /* Information about each argument.  This is an array of `stap_probe_arg',
 222      with each entry representing one argument.  This is only valid if
 223      M_ARGS_PARSED is true.  */
 224   std::vector<struct stap_probe_arg> m_parsed_args;
 225 };
 226
 227 /* When parsing the arguments, we have to establish different precedences
 228    for the various kinds of asm operators.  This enumeration represents those
 229    precedences.
 230
 231    This logic behind this is available at
 232    <http://sourceware.org/binutils/docs/as/Infix-Ops.html#Infix-Ops>, or using
 233    the command "info '(as)Infix Ops'".  */
 234
 235 enum stap_operand_prec
 236 {
 237   /* Lowest precedence, used for non-recognized operands or for the beginning
 238      of the parsing process.  */
 239   STAP_OPERAND_PREC_NONE = 0,
 240
 241   /* Precedence of logical OR.  */
 242   STAP_OPERAND_PREC_LOGICAL_OR,
 243
 244   /* Precedence of logical AND.  */
 245   STAP_OPERAND_PREC_LOGICAL_AND,
 246
 247   /* Precedence of additive (plus, minus) and comparative (equal, less,
 248      greater-than, etc) operands.  */
 249   STAP_OPERAND_PREC_ADD_CMP,
 250
 251   /* Precedence of bitwise operands (bitwise OR, XOR, bitwise AND,
 252      logical NOT).  */
 253   STAP_OPERAND_PREC_BITWISE,
 254
 255   /* Precedence of multiplicative operands (multiplication, division,
 256      remainder, left shift and right shift).  */
 257   STAP_OPERAND_PREC_MUL
 258 };
 259
 260 static void stap_parse_argument_1 (struct stap_parse_info *p, bool has_lhs,
 261                                    enum stap_operand_prec prec);
 262
 263 static void stap_parse_argument_conditionally (struct stap_parse_info *p);
 264
 265 /* Returns true if *S is an operator, false otherwise.  */
 266
 267 static bool stap_is_operator (const char *op);
 268
 269 static void
 270 show_stapexpressiondebug (struct ui_file *file, int from_tty,
 271                           struct cmd_list_element *c, const char *value)
 272 {
 273   fprintf_filtered (file, _("SystemTap Probe expression debugging is %s.\n"),
 274                     value);
 275 }
 276
 277 /* Returns the operator precedence level of OP, or STAP_OPERAND_PREC_NONE
 278    if the operator code was not recognized.  */
 279
 280 static enum stap_operand_prec
 281 stap_get_operator_prec (enum exp_opcode op)
 282 {
 283   switch (op)
 284     {
 285     case BINOP_LOGICAL_OR:
 286       return STAP_OPERAND_PREC_LOGICAL_OR;
 287
 288     case BINOP_LOGICAL_AND:
 289       return STAP_OPERAND_PREC_LOGICAL_AND;
 290
 291     case BINOP_ADD:
 292     case BINOP_SUB:
 293     case BINOP_EQUAL:
 294     case BINOP_NOTEQUAL:
 295     case BINOP_LESS:
 296     case BINOP_LEQ:
 297     case BINOP_GTR:
 298     case BINOP_GEQ:
 299       return STAP_OPERAND_PREC_ADD_CMP;
 300
 301     case BINOP_BITWISE_IOR:
 302     case BINOP_BITWISE_AND:
 303     case BINOP_BITWISE_XOR:
 304     case UNOP_LOGICAL_NOT:
 305       return STAP_OPERAND_PREC_BITWISE;
 306
 307     case BINOP_MUL:
 308     case BINOP_DIV:
 309     case BINOP_REM:
 310     case BINOP_LSH:
 311     case BINOP_RSH:
 312       return STAP_OPERAND_PREC_MUL;
 313
 314     default:
 315       return STAP_OPERAND_PREC_NONE;
 316     }
 317 }
 318
 319 /* Given S, read the operator in it.  Return the EXP_OPCODE which
 320    represents the operator detected, or throw an error if no operator
 321    was found.  */
 322
 323 static enum exp_opcode
 324 stap_get_opcode (const char **s)
 325 {
 326   const char c = **s;
 327   enum exp_opcode op;
 328
 329   *s += 1;
 330
 331   switch (c)
 332     {
 333     case '*':
 334       op = BINOP_MUL;
 335       break;
 336
 337     case '/':
 338       op = BINOP_DIV;
 339       break;
 340
 341     case '%':
 342       op = BINOP_REM;
 343     break;
 344
 345     case '<':
 346       op = BINOP_LESS;
 347       if (**s == '<')
 348         {
 349           *s += 1;
 350           op = BINOP_LSH;
 351         }
 352       else if (**s == '=')
 353         {
 354           *s += 1;
 355           op = BINOP_LEQ;
 356         }
 357       else if (**s == '>')
 358         {
 359           *s += 1;
 360           op = BINOP_NOTEQUAL;
 361         }
 362     break;
 363
 364     case '>':
 365       op = BINOP_GTR;
 366       if (**s == '>')
 367         {
 368           *s += 1;
 369           op = BINOP_RSH;
 370         }
 371       else if (**s == '=')
 372         {
 373           *s += 1;
 374           op = BINOP_GEQ;
 375         }
 376     break;
 377
 378     case '|':
 379       op = BINOP_BITWISE_IOR;
 380       if (**s == '|')
 381         {
 382           *s += 1;
 383           op = BINOP_LOGICAL_OR;
 384         }
 385     break;
 386
 387     case '&':
 388       op = BINOP_BITWISE_AND;
 389       if (**s == '&')
 390         {
 391           *s += 1;
 392           op = BINOP_LOGICAL_AND;
 393         }
 394     break;
 395
 396     case '^':
 397       op = BINOP_BITWISE_XOR;
 398       break;
 399
 400     case '!':
 401       op = UNOP_LOGICAL_NOT;
 402       break;
 403
 404     case '+':
 405       op = BINOP_ADD;
 406       break;
 407
 408     case '-':
 409       op = BINOP_SUB;
 410       break;
 411
 412     case '=':
 413       gdb_assert (**s == '=');
 414       op = BINOP_EQUAL;
 415       break;
 416
 417     default:
 418       error (_("Invalid opcode in expression `%s' for SystemTap"
 419                "probe"), *s);
 420     }
 421
 422   return op;
 423 }
 424
 425 /* Given the bitness of the argument, represented by B, return the
 426    corresponding `struct type *', or throw an error if B is
 427    unknown.  */
 428
 429 static struct type *
 430 stap_get_expected_argument_type (struct gdbarch *gdbarch,
 431                                  enum stap_arg_bitness b,
 432                                  const char *probe_name)
 433 {
 434   switch (b)
 435     {
 436     case STAP_ARG_BITNESS_UNDEFINED:
 437       if (gdbarch_addr_bit (gdbarch) == 32)
 438         return builtin_type (gdbarch)->builtin_uint32;
 439       else
 440         return builtin_type (gdbarch)->builtin_uint64;
 441
 442     case STAP_ARG_BITNESS_8BIT_UNSIGNED:
 443       return builtin_type (gdbarch)->builtin_uint8;
 444
 445     case STAP_ARG_BITNESS_8BIT_SIGNED:
 446       return builtin_type (gdbarch)->builtin_int8;
 447
 448     case STAP_ARG_BITNESS_16BIT_UNSIGNED:
 449       return builtin_type (gdbarch)->builtin_uint16;
 450
 451     case STAP_ARG_BITNESS_16BIT_SIGNED:
 452       return builtin_type (gdbarch)->builtin_int16;
 453
 454     case STAP_ARG_BITNESS_32BIT_SIGNED:
 455       return builtin_type (gdbarch)->builtin_int32;
 456
 457     case STAP_ARG_BITNESS_32BIT_UNSIGNED:
 458       return builtin_type (gdbarch)->builtin_uint32;
 459
 460     case STAP_ARG_BITNESS_64BIT_SIGNED:
 461       return builtin_type (gdbarch)->builtin_int64;
 462
 463     case STAP_ARG_BITNESS_64BIT_UNSIGNED:
 464       return builtin_type (gdbarch)->builtin_uint64;
 465
 466     default:
 467       error (_("Undefined bitness for probe '%s'."), probe_name);
 468       break;
 469     }
 470 }
 471
 472 /* Helper function to check for a generic list of prefixes.  GDBARCH
 473    is the current gdbarch being used.  S is the expression being
 474    analyzed.  If R is not NULL, it will be used to return the found
 475    prefix.  PREFIXES is the list of expected prefixes.
 476
 477    This function does a case-insensitive match.
 478
 479    Return true if any prefix has been found, false otherwise.  */
 480
 481 static bool
 482 stap_is_generic_prefix (struct gdbarch *gdbarch, const char *s,
 483                         const char **r, const char *const *prefixes)
 484 {
 485   const char *const *p;
 486
 487   if (prefixes == NULL)
 488     {
 489       if (r != NULL)
 490         *r = "";
 491
 492       return true;
 493     }
 494
 495   for (p = prefixes; *p != NULL; ++p)
 496     if (strncasecmp (s, *p, strlen (*p)) == 0)
 497       {
 498         if (r != NULL)
 499           *r = *p;
 500
 501         return true;
 502       }
 503
 504   return false;
 505 }
 506
 507 /* Return true if S points to a register prefix, false otherwise.  For
 508    a description of the arguments, look at stap_is_generic_prefix.  */
 509
 510 static bool
 511 stap_is_register_prefix (struct gdbarch *gdbarch, const char *s,
 512                          const char **r)
 513 {
 514   const char *const *t = gdbarch_stap_register_prefixes (gdbarch);
 515
 516   return stap_is_generic_prefix (gdbarch, s, r, t);
 517 }
 518
 519 /* Return true if S points to a register indirection prefix, false
 520    otherwise.  For a description of the arguments, look at
 521    stap_is_generic_prefix.  */
 522
 523 static bool
 524 stap_is_register_indirection_prefix (struct gdbarch *gdbarch, const char *s,
 525                                      const char **r)
 526 {
 527   const char *const *t = gdbarch_stap_register_indirection_prefixes (gdbarch);
 528
 529   return stap_is_generic_prefix (gdbarch, s, r, t);
 530 }
 531
 532 /* Return true if S points to an integer prefix, false otherwise.  For
 533    a description of the arguments, look at stap_is_generic_prefix.
 534
 535    This function takes care of analyzing whether we are dealing with
 536    an expected integer prefix, or, if there is no integer prefix to be
 537    expected, whether we are dealing with a digit.  It does a
 538    case-insensitive match.  */
 539
 540 static bool
 541 stap_is_integer_prefix (struct gdbarch *gdbarch, const char *s,
 542                         const char **r)
 543 {
 544   const char *const *t = gdbarch_stap_integer_prefixes (gdbarch);
 545   const char *const *p;
 546
 547   if (t == NULL)
 548     {
 549       /* A NULL value here means that integers do not have a prefix.
 550          We just check for a digit then.  */
 551       if (r != NULL)
 552         *r = "";
 553
 554       return isdigit (*s) > 0;
 555     }
 556
 557   for (p = t; *p != NULL; ++p)
 558     {
 559       size_t len = strlen (*p);
 560
 561       if ((len == 0 && isdigit (*s))
 562           || (len > 0 && strncasecmp (s, *p, len) == 0))
 563         {
 564           /* Integers may or may not have a prefix.  The "len == 0"
 565              check covers the case when integers do not have a prefix
 566              (therefore, we just check if we have a digit).  The call
 567              to "strncasecmp" covers the case when they have a
 568              prefix.  */
 569           if (r != NULL)
 570             *r = *p;
 571
 572           return true;
 573         }
 574     }
 575
 576   return false;
 577 }
 578
 579 /* Helper function to check for a generic list of suffixes.  If we are
 580    not expecting any suffixes, then it just returns 1.  If we are
 581    expecting at least one suffix, then it returns true if a suffix has
 582    been found, false otherwise.  GDBARCH is the current gdbarch being
 583    used.  S is the expression being analyzed.  If R is not NULL, it
 584    will be used to return the found suffix.  SUFFIXES is the list of
 585    expected suffixes.  This function does a case-insensitive
 586    match.  */
 587
 588 static bool
 589 stap_generic_check_suffix (struct gdbarch *gdbarch, const char *s,
 590                            const char **r, const char *const *suffixes)
 591 {
 592   const char *const *p;
 593   bool found = false;
 594
 595   if (suffixes == NULL)
 596     {
 597       if (r != NULL)
 598         *r = "";
 599
 600       return true;
 601     }
 602
 603   for (p = suffixes; *p != NULL; ++p)
 604     if (strncasecmp (s, *p, strlen (*p)) == 0)
 605       {
 606         if (r != NULL)
 607           *r = *p;
 608
 609         found = true;
 610         break;
 611       }
 612
 613   return found;
 614 }
 615
 616 /* Return true if S points to an integer suffix, false otherwise.  For
 617    a description of the arguments, look at
 618    stap_generic_check_suffix.  */
 619
 620 static bool
 621 stap_check_integer_suffix (struct gdbarch *gdbarch, const char *s,
 622                            const char **r)
 623 {
 624   const char *const *p = gdbarch_stap_integer_suffixes (gdbarch);
 625
 626   return stap_generic_check_suffix (gdbarch, s, r, p);
 627 }
 628
 629 /* Return true if S points to a register suffix, false otherwise.  For
 630    a description of the arguments, look at
 631    stap_generic_check_suffix.  */
 632
 633 static bool
 634 stap_check_register_suffix (struct gdbarch *gdbarch, const char *s,
 635                             const char **r)
 636 {
 637   const char *const *p = gdbarch_stap_register_suffixes (gdbarch);
 638
 639   return stap_generic_check_suffix (gdbarch, s, r, p);
 640 }
 641
 642 /* Return true if S points to a register indirection suffix, false
 643    otherwise.  For a description of the arguments, look at
 644    stap_generic_check_suffix.  */
 645
 646 static bool
 647 stap_check_register_indirection_suffix (struct gdbarch *gdbarch, const char *s,
 648                                         const char **r)
 649 {
 650   const char *const *p = gdbarch_stap_register_indirection_suffixes (gdbarch);
 651
 652   return stap_generic_check_suffix (gdbarch, s, r, p);
 653 }
 654
 655 /* Function responsible for parsing a register operand according to
 656    SystemTap parlance.  Assuming:
 657
 658    RP  = register prefix
 659    RS  = register suffix
 660    RIP = register indirection prefix
 661    RIS = register indirection suffix
 662
 663    Then a register operand can be:
 664
 665    [RIP] [RP] REGISTER [RS] [RIS]
 666
 667    This function takes care of a register's indirection, displacement and
 668    direct access.  It also takes into consideration the fact that some
 669    registers are named differently inside and outside GDB, e.g., PPC's
 670    general-purpose registers are represented by integers in the assembly
 671    language (e.g., `15' is the 15th general-purpose register), but inside
 672    GDB they have a prefix (the letter `r') appended.  */
 673
 674 static void
 675 stap_parse_register_operand (struct stap_parse_info *p)
 676 {
 677   /* Simple flag to indicate whether we have seen a minus signal before
 678      certain number.  */
 679   bool got_minus = false;
 680   /* Flags to indicate whether this register access is being displaced and/or
 681      indirected.  */
 682   bool disp_p = false;
 683   bool indirect_p = false;
 684   struct gdbarch *gdbarch = p->gdbarch;
 685   /* Needed to generate the register name as a part of an expression.  */
 686   struct stoken str;
 687   /* Variables used to extract the register name from the probe's
 688      argument.  */
 689   const char *start;
 690   const char *gdb_reg_prefix = gdbarch_stap_gdb_register_prefix (gdbarch);
 691   const char *gdb_reg_suffix = gdbarch_stap_gdb_register_suffix (gdbarch);
 692   const char *reg_prefix;
 693   const char *reg_ind_prefix;
 694   const char *reg_suffix;
 695   const char *reg_ind_suffix;
 696
 697   /* Checking for a displacement argument.  */
 698   if (*p->arg == '+')
 699     {
 700       /* If it's a plus sign, we don't need to do anything, just advance the
 701          pointer.  */
 702       ++p->arg;
 703     }
 704   else if (*p->arg == '-')
 705     {
 706       got_minus = true;
 707       ++p->arg;
 708     }
 709
 710   if (isdigit (*p->arg))
 711     {
 712       /* The value of the displacement.  */
 713       long displacement;
 714       char *endp;
 715
 716       disp_p = true;
 717       displacement = strtol (p->arg, &endp, 10);
 718       p->arg = endp;
 719
 720       /* Generating the expression for the displacement.  */
 721       write_exp_elt_opcode (&p->pstate, OP_LONG);
 722       write_exp_elt_type (&p->pstate, builtin_type (gdbarch)->builtin_long);
 723       write_exp_elt_longcst (&p->pstate, displacement);
 724       write_exp_elt_opcode (&p->pstate, OP_LONG);
 725       if (got_minus)
 726         write_exp_elt_opcode (&p->pstate, UNOP_NEG);
 727     }
 728
 729   /* Getting rid of register indirection prefix.  */
 730   if (stap_is_register_indirection_prefix (gdbarch, p->arg, &reg_ind_prefix))
 731     {
 732       indirect_p = true;
 733       p->arg += strlen (reg_ind_prefix);
 734     }
 735
 736   if (disp_p && !indirect_p)
 737     error (_("Invalid register displacement syntax on expression `%s'."),
 738            p->saved_arg);
 739
 740   /* Getting rid of register prefix.  */
 741   if (stap_is_register_prefix (gdbarch, p->arg, &reg_prefix))
 742     p->arg += strlen (reg_prefix);
 743
 744   /* Now we should have only the register name.  Let's extract it and get
 745      the associated number.  */
 746   start = p->arg;
 747
 748   /* We assume the register name is composed by letters and numbers.  */
 749   while (isalnum (*p->arg))
 750     ++p->arg;
 751
 752   std::string regname (start, p->arg - start);
 753
 754   /* We only add the GDB's register prefix/suffix if we are dealing with
 755      a numeric register.  */
 756   if (isdigit (*start))
 757     {
 758       if (gdb_reg_prefix != NULL)
 759         regname = gdb_reg_prefix + regname;
 760
 761       if (gdb_reg_suffix != NULL)
 762         regname += gdb_reg_suffix;
 763     }
 764
 765   int regnum = user_reg_map_name_to_regnum (gdbarch, regname.c_str (),
 766                                             regname.size ());
 767
 768   /* Is this a valid register name?  */
 769   if (regnum == -1)
 770     error (_("Invalid register name `%s' on expression `%s'."),
 771            regname.c_str (), p->saved_arg);
 772
 773   /* Check if there's any special treatment that the arch-specific
 774      code would like to perform on the register name.  */
 775   if (gdbarch_stap_adjust_register_p (gdbarch))
 776     {
 777       std::string newregname
 778         = gdbarch_stap_adjust_register (gdbarch, p, regname, regnum);
 779
 780       if (regname != newregname)
 781         {
 782           /* This is just a check we perform to make sure that the
 783              arch-dependent code has provided us with a valid
 784              register name.  */
 785           regnum = user_reg_map_name_to_regnum (gdbarch, newregname.c_str (),
 786                                                 newregname.size ());
 787
 788           if (regnum == -1)
 789             internal_error (__FILE__, __LINE__,
 790                             _("Invalid register name '%s' after replacing it"
 791                               " (previous name was '%s')"),
 792                             newregname.c_str (), regname.c_str ());
 793
 794           regname = newregname;
 795         }
 796     }
 797
 798   write_exp_elt_opcode (&p->pstate, OP_REGISTER);
 799   str.ptr = regname.c_str ();
 800   str.length = regname.size ();
 801   write_exp_string (&p->pstate, str);
 802   write_exp_elt_opcode (&p->pstate, OP_REGISTER);
 803
 804   if (indirect_p)
 805     {
 806       if (disp_p)
 807         write_exp_elt_opcode (&p->pstate, BINOP_ADD);
 808
 809       /* Casting to the expected type.  */
 810       write_exp_elt_opcode (&p->pstate, UNOP_CAST);
 811       write_exp_elt_type (&p->pstate, lookup_pointer_type (p->arg_type));
 812       write_exp_elt_opcode (&p->pstate, UNOP_CAST);
 813
 814       write_exp_elt_opcode (&p->pstate, UNOP_IND);
 815     }
 816
 817   /* Getting rid of the register name suffix.  */
 818   if (stap_check_register_suffix (gdbarch, p->arg, &reg_suffix))
 819     p->arg += strlen (reg_suffix);
 820   else
 821     error (_("Missing register name suffix on expression `%s'."),
 822            p->saved_arg);
 823
 824   /* Getting rid of the register indirection suffix.  */
 825   if (indirect_p)
 826     {
 827       if (stap_check_register_indirection_suffix (gdbarch, p->arg,
 828                                                   &reg_ind_suffix))
 829         p->arg += strlen (reg_ind_suffix);
 830       else
 831         error (_("Missing indirection suffix on expression `%s'."),
 832                p->saved_arg);
 833     }
 834 }
 835
 836 /* This function is responsible for parsing a single operand.
 837
 838    A single operand can be:
 839
 840       - an unary operation (e.g., `-5', `~2', or even with subexpressions
 841         like `-(2 + 1)')
 842       - a register displacement, which will be treated as a register
 843         operand (e.g., `-4(%eax)' on x86)
 844       - a numeric constant, or
 845       - a register operand (see function `stap_parse_register_operand')
 846
 847    The function also calls special-handling functions to deal with
 848    unrecognized operands, allowing arch-specific parsers to be
 849    created.  */
 850
 851 static void
 852 stap_parse_single_operand (struct stap_parse_info *p)
 853 {
 854   struct gdbarch *gdbarch = p->gdbarch;
 855   const char *int_prefix = NULL;
 856
 857   /* We first try to parse this token as a "special token".  */
 858   if (gdbarch_stap_parse_special_token_p (gdbarch)
 859       && (gdbarch_stap_parse_special_token (gdbarch, p) != 0))
 860     {
 861       /* If the return value of the above function is not zero,
 862          it means it successfully parsed the special token.
 863
 864          If it is NULL, we try to parse it using our method.  */
 865       return;
 866     }
 867
 868   if (*p->arg == '-' || *p->arg == '~' || *p->arg == '+')
 869     {
 870       char c = *p->arg;
 871       /* We use this variable to do a lookahead.  */
 872       const char *tmp = p->arg;
 873       bool has_digit = false;
 874
 875       /* Skipping signal.  */
 876       ++tmp;
 877
 878       /* This is an unary operation.  Here is a list of allowed tokens
 879          here:
 880
 881          - numeric literal;
 882          - number (from register displacement)
 883          - subexpression (beginning with `(')
 884
 885          We handle the register displacement here, and the other cases
 886          recursively.  */
 887       if (p->inside_paren_p)
 888         tmp = skip_spaces (tmp);
 889
 890       while (isdigit (*tmp))
 891         {
 892           /* We skip the digit here because we are only interested in
 893              knowing what kind of unary operation this is.  The digit
 894              will be handled by one of the functions that will be
 895              called below ('stap_parse_argument_conditionally' or
 896              'stap_parse_register_operand').  */
 897           ++tmp;
 898           has_digit = true;
 899         }
 900
 901       if (has_digit && stap_is_register_indirection_prefix (gdbarch, tmp,
 902                                                             NULL))
 903         {
 904           /* If we are here, it means it is a displacement.  The only
 905              operations allowed here are `-' and `+'.  */
 906           if (c != '-' && c != '+')
 907             error (_("Invalid operator `%c' for register displacement "
 908                      "on expression `%s'."), c, p->saved_arg);
 909
 910           stap_parse_register_operand (p);
 911         }
 912       else
 913         {
 914           /* This is not a displacement.  We skip the operator, and
 915              deal with it when the recursion returns.  */
 916           ++p->arg;
 917           stap_parse_argument_conditionally (p);
 918           if (c == '-')
 919             write_exp_elt_opcode (&p->pstate, UNOP_NEG);
 920           else if (c == '~')
 921             write_exp_elt_opcode (&p->pstate, UNOP_COMPLEMENT);
 922         }
 923     }
 924   else if (isdigit (*p->arg))
 925     {
 926       /* A temporary variable, needed for lookahead.  */
 927       const char *tmp = p->arg;
 928       char *endp;
 929       long number;
 930
 931       /* We can be dealing with a numeric constant, or with a register
 932          displacement.  */
 933       number = strtol (tmp, &endp, 10);
 934       tmp = endp;
 935
 936       if (p->inside_paren_p)
 937         tmp = skip_spaces (tmp);
 938
 939       /* If "stap_is_integer_prefix" returns true, it means we can
 940          accept integers without a prefix here.  But we also need to
 941          check whether the next token (i.e., "tmp") is not a register
 942          indirection prefix.  */
 943       if (stap_is_integer_prefix (gdbarch, p->arg, NULL)
 944           && !stap_is_register_indirection_prefix (gdbarch, tmp, NULL))
 945         {
 946           const char *int_suffix;
 947
 948           /* We are dealing with a numeric constant.  */
 949           write_exp_elt_opcode (&p->pstate, OP_LONG);
 950           write_exp_elt_type (&p->pstate,
 951                               builtin_type (gdbarch)->builtin_long);
 952           write_exp_elt_longcst (&p->pstate, number);
 953           write_exp_elt_opcode (&p->pstate, OP_LONG);
 954
 955           p->arg = tmp;
 956
 957           if (stap_check_integer_suffix (gdbarch, p->arg, &int_suffix))
 958             p->arg += strlen (int_suffix);
 959           else
 960             error (_("Invalid constant suffix on expression `%s'."),
 961                    p->saved_arg);
 962         }
 963       else if (stap_is_register_indirection_prefix (gdbarch, tmp, NULL))
 964         stap_parse_register_operand (p);
 965       else
 966         error (_("Unknown numeric token on expression `%s'."),
 967                p->saved_arg);
 968     }
 969   else if (stap_is_integer_prefix (gdbarch, p->arg, &int_prefix))
 970     {
 971       /* We are dealing with a numeric constant.  */
 972       long number;
 973       char *endp;
 974       const char *int_suffix;
 975
 976       p->arg += strlen (int_prefix);
 977       number = strtol (p->arg, &endp, 10);
 978       p->arg = endp;
 979
 980       write_exp_elt_opcode (&p->pstate, OP_LONG);
 981       write_exp_elt_type (&p->pstate, builtin_type (gdbarch)->builtin_long);
 982       write_exp_elt_longcst (&p->pstate, number);
 983       write_exp_elt_opcode (&p->pstate, OP_LONG);
 984
 985       if (stap_check_integer_suffix (gdbarch, p->arg, &int_suffix))
 986         p->arg += strlen (int_suffix);
 987       else
 988         error (_("Invalid constant suffix on expression `%s'."),
 989                p->saved_arg);
 990     }
 991   else if (stap_is_register_prefix (gdbarch, p->arg, NULL)
 992            || stap_is_register_indirection_prefix (gdbarch, p->arg, NULL))
 993     stap_parse_register_operand (p);
 994   else
 995     error (_("Operator `%c' not recognized on expression `%s'."),
 996            *p->arg, p->saved_arg);
 997 }
 998
 999 /* This function parses an argument conditionally, based on single or
1000    non-single operands.  A non-single operand would be a parenthesized
1001    expression (e.g., `(2 + 1)'), and a single operand is anything that
1002    starts with `-', `~', `+' (i.e., unary operators), a digit, or
1003    something recognized by `gdbarch_stap_is_single_operand'.  */
1004
1005 static void
1006 stap_parse_argument_conditionally (struct stap_parse_info *p)
1007 {
1008   gdb_assert (gdbarch_stap_is_single_operand_p (p->gdbarch));
1009
1010   if (*p->arg == '-' || *p->arg == '~' || *p->arg == '+' /* Unary.  */
1011       || isdigit (*p->arg)
1012       || gdbarch_stap_is_single_operand (p->gdbarch, p->arg))
1013     stap_parse_single_operand (p);
1014   else if (*p->arg == '(')
1015     {
1016       /* We are dealing with a parenthesized operand.  It means we
1017          have to parse it as it was a separate expression, without
1018          left-side or precedence.  */
1019       ++p->arg;
1020       p->arg = skip_spaces (p->arg);
1021       ++p->inside_paren_p;
1022
1023       stap_parse_argument_1 (p, 0, STAP_OPERAND_PREC_NONE);
1024
1025       --p->inside_paren_p;
1026       if (*p->arg != ')')
1027         error (_("Missign close-paren on expression `%s'."),
1028                p->saved_arg);
1029
1030       ++p->arg;
1031       if (p->inside_paren_p)
1032         p->arg = skip_spaces (p->arg);
1033     }
1034   else
1035     error (_("Cannot parse expression `%s'."), p->saved_arg);
1036 }
1037
1038 /* Helper function for `stap_parse_argument'.  Please, see its comments to
1039    better understand what this function does.  */
1040
1041 static void
1042 stap_parse_argument_1 (struct stap_parse_info *p, bool has_lhs,
1043                        enum stap_operand_prec prec)
1044 {
1045   /* This is an operator-precedence parser.
1046
1047      We work with left- and right-sides of expressions, and
1048      parse them depending on the precedence of the operators
1049      we find.  */
1050
1051   gdb_assert (p->arg != NULL);
1052
1053   if (p->inside_paren_p)
1054     p->arg = skip_spaces (p->arg);
1055
1056   if (!has_lhs)
1057     {
1058       /* We were called without a left-side, either because this is the
1059          first call, or because we were called to parse a parenthesized
1060          expression.  It doesn't really matter; we have to parse the
1061          left-side in order to continue the process.  */
1062       stap_parse_argument_conditionally (p);
1063     }
1064
1065   /* Start to parse the right-side, and to "join" left and right sides
1066      depending on the operation specified.
1067
1068      This loop shall continue until we run out of characters in the input,
1069      or until we find a close-parenthesis, which means that we've reached
1070      the end of a sub-expression.  */
1071   while (*p->arg != '\0' && *p->arg != ')' && !isspace (*p->arg))
1072     {
1073       const char *tmp_exp_buf;
1074       enum exp_opcode opcode;
1075       enum stap_operand_prec cur_prec;
1076
1077       if (!stap_is_operator (p->arg))
1078         error (_("Invalid operator `%c' on expression `%s'."), *p->arg,
1079                p->saved_arg);
1080
1081       /* We have to save the current value of the expression buffer because
1082          the `stap_get_opcode' modifies it in order to get the current
1083          operator.  If this operator's precedence is lower than PREC, we
1084          should return and not advance the expression buffer pointer.  */
1085       tmp_exp_buf = p->arg;
1086       opcode = stap_get_opcode (&tmp_exp_buf);
1087
1088       cur_prec = stap_get_operator_prec (opcode);
1089       if (cur_prec < prec)
1090         {
1091           /* If the precedence of the operator that we are seeing now is
1092              lower than the precedence of the first operator seen before
1093              this parsing process began, it means we should stop parsing
1094              and return.  */
1095           break;
1096         }
1097
1098       p->arg = tmp_exp_buf;
1099       if (p->inside_paren_p)
1100         p->arg = skip_spaces (p->arg);
1101
1102       /* Parse the right-side of the expression.  */
1103       stap_parse_argument_conditionally (p);
1104
1105       /* While we still have operators, try to parse another
1106          right-side, but using the current right-side as a left-side.  */
1107       while (*p->arg != '\0' && stap_is_operator (p->arg))
1108         {
1109           enum exp_opcode lookahead_opcode;
1110           enum stap_operand_prec lookahead_prec;
1111
1112           /* Saving the current expression buffer position.  The explanation
1113              is the same as above.  */
1114           tmp_exp_buf = p->arg;
1115           lookahead_opcode = stap_get_opcode (&tmp_exp_buf);
1116           lookahead_prec = stap_get_operator_prec (lookahead_opcode);
1117
1118           if (lookahead_prec <= prec)
1119             {
1120               /* If we are dealing with an operator whose precedence is lower
1121                  than the first one, just abandon the attempt.  */
1122               break;
1123             }
1124
1125           /* Parse the right-side of the expression, but since we already
1126              have a left-side at this point, set `has_lhs' to 1.  */
1127           stap_parse_argument_1 (p, 1, lookahead_prec);
1128         }
1129
1130       write_exp_elt_opcode (&p->pstate, opcode);
1131     }
1132 }
1133
1134 /* Parse a probe's argument.
1135
1136    Assuming that:
1137
1138    LP = literal integer prefix
1139    LS = literal integer suffix
1140
1141    RP = register prefix
1142    RS = register suffix
1143
1144    RIP = register indirection prefix
1145    RIS = register indirection suffix
1146
1147    This routine assumes that arguments' tokens are of the form:
1148
1149    - [LP] NUMBER [LS]
1150    - [RP] REGISTER [RS]
1151    - [RIP] [RP] REGISTER [RS] [RIS]
1152    - If we find a number without LP, we try to parse it as a literal integer
1153    constant (if LP == NULL), or as a register displacement.
1154    - We count parenthesis, and only skip whitespaces if we are inside them.
1155    - If we find an operator, we skip it.
1156
1157    This function can also call a special function that will try to match
1158    unknown tokens.  It will return the expression_up generated from
1159    parsing the argument.  */
1160
1161 static expression_up
1162 stap_parse_argument (const char **arg, struct type *atype,
1163                      struct gdbarch *gdbarch)
1164 {
1165   /* We need to initialize the expression buffer, in order to begin
1166      our parsing efforts.  We use language_c here because we may need
1167      to do pointer arithmetics.  */
1168   struct stap_parse_info p (*arg, atype, language_def (language_c),
1169                             gdbarch);
1170
1171   stap_parse_argument_1 (&p, 0, STAP_OPERAND_PREC_NONE);
1172
1173   gdb_assert (p.inside_paren_p == 0);
1174
1175   /* Casting the final expression to the appropriate type.  */
1176   write_exp_elt_opcode (&p.pstate, UNOP_CAST);
1177   write_exp_elt_type (&p.pstate, atype);
1178   write_exp_elt_opcode (&p.pstate, UNOP_CAST);
1179
1180   p.arg = skip_spaces (p.arg);
1181   *arg = p.arg;
1182
1183   return p.pstate.release ();
1184 }
1185
1186 /* Implementation of 'parse_arguments' method.  */
1187
1188 void
1189 stap_probe::parse_arguments (struct gdbarch *gdbarch)
1190 {
1191   const char *cur;
1192
1193   gdb_assert (!m_have_parsed_args);
1194   cur = m_unparsed_args_text;
1195   m_have_parsed_args = true;
1196
1197   if (cur == NULL || *cur == '\0' || *cur == ':')
1198     return;
1199
1200   while (*cur != '\0')
1201     {
1202       enum stap_arg_bitness bitness;
1203       bool got_minus = false;
1204
1205       /* We expect to find something like:
1206
1207          N@OP
1208
1209          Where `N' can be [+,-][1,2,4,8].  This is not mandatory, so
1210          we check it here.  If we don't find it, go to the next
1211          state.  */
1212       if ((cur[0] == '-' && isdigit (cur[1]) && cur[2] == '@')
1213           || (isdigit (cur[0]) && cur[1] == '@'))
1214         {
1215           if (*cur == '-')
1216             {
1217               /* Discard the `-'.  */
1218               ++cur;
1219               got_minus = true;
1220             }
1221
1222           /* Defining the bitness.  */
1223           switch (*cur)
1224             {
1225             case '1':
1226               bitness = (got_minus ? STAP_ARG_BITNESS_8BIT_SIGNED
1227                          : STAP_ARG_BITNESS_8BIT_UNSIGNED);
1228               break;
1229
1230             case '2':
1231               bitness = (got_minus ? STAP_ARG_BITNESS_16BIT_SIGNED
1232                          : STAP_ARG_BITNESS_16BIT_UNSIGNED);
1233               break;
1234
1235             case '4':
1236               bitness = (got_minus ? STAP_ARG_BITNESS_32BIT_SIGNED
1237                          : STAP_ARG_BITNESS_32BIT_UNSIGNED);
1238               break;
1239
1240             case '8':
1241               bitness = (got_minus ? STAP_ARG_BITNESS_64BIT_SIGNED
1242                          : STAP_ARG_BITNESS_64BIT_UNSIGNED);
1243               break;
1244
1245             default:
1246               {
1247                 /* We have an error, because we don't expect anything
1248                    except 1, 2, 4 and 8.  */
1249                 warning (_("unrecognized bitness %s%c' for probe `%s'"),
1250                          got_minus ? "`-" : "`", *cur,
1251                          this->get_name ().c_str ());
1252                 return;
1253               }
1254             }
1255           /* Discard the number and the `@' sign.  */
1256           cur += 2;
1257         }
1258       else
1259         bitness = STAP_ARG_BITNESS_UNDEFINED;
1260
1261       struct type *atype
1262         = stap_get_expected_argument_type (gdbarch, bitness,
1263                                            this->get_name ().c_str ());
1264
1265       expression_up expr = stap_parse_argument (&cur, atype, gdbarch);
1266
1267       if (stap_expression_debug)
1268         dump_raw_expression (expr.get (), gdb_stdlog,
1269                              "before conversion to prefix form");
1270
1271       prefixify_expression (expr.get ());
1272
1273       if (stap_expression_debug)
1274         dump_prefix_expression (expr.get (), gdb_stdlog);
1275
1276       m_parsed_args.emplace_back (bitness, atype, std::move (expr));
1277
1278       /* Start it over again.  */
1279       cur = skip_spaces (cur);
1280     }
1281 }
1282
1283 /* Helper function to relocate an address.  */
1284
1285 static CORE_ADDR
1286 relocate_address (CORE_ADDR address, struct objfile *objfile)
1287 {
1288   return address + ANOFFSET (objfile->section_offsets,
1289                              SECT_OFF_DATA (objfile));
1290 }
1291
1292 /* Implementation of the get_relocated_address method.  */
1293
1294 CORE_ADDR
1295 stap_probe::get_relocated_address (struct objfile *objfile)
1296 {
1297   return relocate_address (this->get_address (), objfile);
1298 }
1299
1300 /* Given PROBE, returns the number of arguments present in that probe's
1301    argument string.  */
1302
1303 unsigned
1304 stap_probe::get_argument_count (struct frame_info *frame)
1305 {
1306   struct gdbarch *gdbarch = get_frame_arch (frame);
1307
1308   if (!m_have_parsed_args)
1309     {
1310       if (this->can_evaluate_arguments ())
1311         this->parse_arguments (gdbarch);
1312       else
1313         {
1314           static bool have_warned_stap_incomplete = false;
1315
1316           if (!have_warned_stap_incomplete)
1317             {
1318               warning (_(
1319 "The SystemTap SDT probe support is not fully implemented on this target;\n"
1320 "you will not be able to inspect the arguments of the probes.\n"
1321 "Please report a bug against GDB requesting a port to this target."));
1322               have_warned_stap_incomplete = true;
1323             }
1324
1325           /* Marking the arguments as "already parsed".  */
1326           m_have_parsed_args = true;
1327         }
1328     }
1329
1330   gdb_assert (m_have_parsed_args);
1331   return m_parsed_args.size ();
1332 }
1333
1334 /* Return true if OP is a valid operator inside a probe argument, or
1335    false otherwise.  */
1336
1337 static bool
1338 stap_is_operator (const char *op)
1339 {
1340   bool ret = true;
1341
1342   switch (*op)
1343     {
1344     case '*':
1345     case '/':
1346     case '%':
1347     case '^':
1348     case '!':
1349     case '+':
1350     case '-':
1351     case '<':
1352     case '>':
1353     case '|':
1354     case '&':
1355       break;
1356
1357     case '=':
1358       if (op[1] != '=')
1359         ret = false;
1360       break;
1361
1362     default:
1363       /* We didn't find any operator.  */
1364       ret = false;
1365     }
1366
1367   return ret;
1368 }
1369
1370 /* Implement the `can_evaluate_arguments' method.  */
1371
1372 bool
1373 stap_probe::can_evaluate_arguments () const
1374 {
1375   struct gdbarch *gdbarch = this->get_gdbarch ();
1376
1377   /* For SystemTap probes, we have to guarantee that the method
1378      stap_is_single_operand is defined on gdbarch.  If it is not, then it
1379      means that argument evaluation is not implemented on this target.  */
1380   return gdbarch_stap_is_single_operand_p (gdbarch);
1381 }
1382
1383 /* Evaluate the probe's argument N (indexed from 0), returning a value
1384    corresponding to it.  Assertion is thrown if N does not exist.  */
1385
1386 struct value *
1387 stap_probe::evaluate_argument (unsigned n, struct frame_info *frame)
1388 {
1389   struct stap_probe_arg *arg;
1390   int pos = 0;
1391   struct gdbarch *gdbarch = get_frame_arch (frame);
1392
1393   arg = this->get_arg_by_number (n, gdbarch);
1394   return evaluate_subexp_standard (arg->atype, arg->aexpr.get (), &pos,
1395                                    EVAL_NORMAL);
1396 }
1397
1398 /* Compile the probe's argument N (indexed from 0) to agent expression.
1399    Assertion is thrown if N does not exist.  */
1400
1401 void
1402 stap_probe::compile_to_ax (struct agent_expr *expr, struct axs_value *value,
1403                            unsigned n)
1404 {
1405   struct stap_probe_arg *arg;
1406   union exp_element *pc;
1407
1408   arg = this->get_arg_by_number (n, expr->gdbarch);
1409
1410   pc = arg->aexpr->elts;
1411   gen_expr (arg->aexpr.get (), &pc, expr, value);
1412
1413   require_rvalue (expr, value);
1414   value->type = arg->atype;
1415 }
1416 \f
1417
1418 /* Set or clear a SystemTap semaphore.  ADDRESS is the semaphore's
1419    address.  SET is zero if the semaphore should be cleared, or one if
1420    it should be set.  This is a helper function for
1421    'stap_probe::set_semaphore' and 'stap_probe::clear_semaphore'.  */
1422
1423 static void
1424 stap_modify_semaphore (CORE_ADDR address, int set, struct gdbarch *gdbarch)
1425 {
1426   gdb_byte bytes[sizeof (LONGEST)];
1427   /* The ABI specifies "unsigned short".  */
1428   struct type *type = builtin_type (gdbarch)->builtin_unsigned_short;
1429   ULONGEST value;
1430
1431   if (address == 0)
1432     return;
1433
1434   /* Swallow errors.  */
1435   if (target_read_memory (address, bytes, TYPE_LENGTH (type)) != 0)
1436     {
1437       warning (_("Could not read the value of a SystemTap semaphore."));
1438       return;
1439     }
1440
1441   value = extract_unsigned_integer (bytes, TYPE_LENGTH (type),
1442                                     gdbarch_byte_order (gdbarch));
1443   /* Note that we explicitly don't worry about overflow or
1444      underflow.  */
1445   if (set)
1446     ++value;
1447   else
1448     --value;
1449
1450   store_unsigned_integer (bytes, TYPE_LENGTH (type),
1451                           gdbarch_byte_order (gdbarch), value);
1452
1453   if (target_write_memory (address, bytes, TYPE_LENGTH (type)) != 0)
1454     warning (_("Could not write the value of a SystemTap semaphore."));
1455 }
1456
1457 /* Implementation of the 'set_semaphore' method.
1458
1459    SystemTap semaphores act as reference counters, so calls to this
1460    function must be paired with calls to 'clear_semaphore'.
1461
1462    This function and 'clear_semaphore' race with another tool
1463    changing the probes, but that is too rare to care.  */
1464
1465 void
1466 stap_probe::set_semaphore (struct objfile *objfile, struct gdbarch *gdbarch)
1467 {
1468   stap_modify_semaphore (relocate_address (m_sem_addr, objfile), 1, gdbarch);
1469 }
1470
1471 /* Implementation of the 'clear_semaphore' method.  */
1472
1473 void
1474 stap_probe::clear_semaphore (struct objfile *objfile, struct gdbarch *gdbarch)
1475 {
1476   stap_modify_semaphore (relocate_address (m_sem_addr, objfile), 0, gdbarch);
1477 }
1478
1479 /* Implementation of the 'get_static_ops' method.  */
1480
1481 const static_probe_ops *
1482 stap_probe::get_static_ops () const
1483 {
1484   return &stap_static_probe_ops;
1485 }
1486
1487 /* Implementation of the 'gen_info_probes_table_values' method.  */
1488
1489 std::vector<const char *>
1490 stap_probe::gen_info_probes_table_values () const
1491 {
1492   const char *val = NULL;
1493
1494   if (m_sem_addr != 0)
1495     val = print_core_address (this->get_gdbarch (), m_sem_addr);
1496
1497   return std::vector<const char *> { val };
1498 }
1499
1500 /* Helper function that parses the information contained in a
1501    SystemTap's probe.  Basically, the information consists in:
1502
1503    - Probe's PC address;
1504    - Link-time section address of `.stapsdt.base' section;
1505    - Link-time address of the semaphore variable, or ZERO if the
1506      probe doesn't have an associated semaphore;
1507    - Probe's provider name;
1508    - Probe's name;
1509    - Probe's argument format.  */
1510
1511 static void
1512 handle_stap_probe (struct objfile *objfile, struct sdt_note *el,
1513                    std::vector<std::unique_ptr<probe>> *probesp,
1514                    CORE_ADDR base)
1515 {
1516   bfd *abfd = objfile->obfd;
1517   int size = bfd_get_arch_size (abfd) / 8;
1518   struct gdbarch *gdbarch = get_objfile_arch (objfile);
1519   struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
1520
1521   /* Provider and the name of the probe.  */
1522   const char *provider = (const char *) &el->data[3 * size];
1523   const char *name = ((const char *)
1524                       memchr (provider, '\0',
1525                               (char *) el->data + el->size - provider));
1526   /* Making sure there is a name.  */
1527   if (name == NULL)
1528     {
1529       complaint (_("corrupt probe name when reading `%s'"),
1530                  objfile_name (objfile));
1531
1532       /* There is no way to use a probe without a name or a provider, so
1533          returning here makes sense.  */
1534       return;
1535     }
1536   else
1537     ++name;
1538
1539   /* Retrieving the probe's address.  */
1540   CORE_ADDR address = extract_typed_address (&el->data[0], ptr_type);
1541
1542   /* Link-time sh_addr of `.stapsdt.base' section.  */
1543   CORE_ADDR base_ref = extract_typed_address (&el->data[size], ptr_type);
1544
1545   /* Semaphore address.  */
1546   CORE_ADDR sem_addr = extract_typed_address (&el->data[2 * size], ptr_type);
1547
1548   address += base - base_ref;
1549   if (sem_addr != 0)
1550     sem_addr += base - base_ref;
1551
1552   /* Arguments.  We can only extract the argument format if there is a valid
1553      name for this probe.  */
1554   const char *probe_args = ((const char*)
1555                             memchr (name, '\0',
1556                                     (char *) el->data + el->size - name));
1557
1558   if (probe_args != NULL)
1559     ++probe_args;
1560
1561   if (probe_args == NULL
1562       || (memchr (probe_args, '\0', (char *) el->data + el->size - name)
1563           != el->data + el->size - 1))
1564     {
1565       complaint (_("corrupt probe argument when reading `%s'"),
1566                  objfile_name (objfile));
1567       /* If the argument string is NULL, it means some problem happened with
1568          it.  So we return.  */
1569       return;
1570     }
1571
1572   stap_probe *ret = new stap_probe (std::string (name), std::string (provider),
1573                                     address, gdbarch, sem_addr, probe_args);
1574
1575   /* Successfully created probe.  */
1576   probesp->emplace_back (ret);
1577 }
1578
1579 /* Helper function which tries to find the base address of the SystemTap
1580    base section named STAP_BASE_SECTION_NAME.  */
1581
1582 static void
1583 get_stap_base_address_1 (bfd *abfd, asection *sect, void *obj)
1584 {
1585   asection **ret = (asection **) obj;
1586
1587   if ((sect->flags & (SEC_DATA | SEC_ALLOC | SEC_HAS_CONTENTS))
1588       && sect->name && !strcmp (sect->name, STAP_BASE_SECTION_NAME))
1589     *ret = sect;
1590 }
1591
1592 /* Helper function which iterates over every section in the BFD file,
1593    trying to find the base address of the SystemTap base section.
1594    Returns 1 if found (setting BASE to the proper value), zero otherwise.  */
1595
1596 static int
1597 get_stap_base_address (bfd *obfd, bfd_vma *base)
1598 {
1599   asection *ret = NULL;
1600
1601   bfd_map_over_sections (obfd, get_stap_base_address_1, (void *) &ret);
1602
1603   if (ret == NULL)
1604     {
1605       complaint (_("could not obtain base address for "
1606                                         "SystemTap section on objfile `%s'."),
1607                  obfd->filename);
1608       return 0;
1609     }
1610
1611   if (base != NULL)
1612     *base = ret->vma;
1613
1614   return 1;
1615 }
1616
1617 /* Implementation of the 'is_linespec' method.  */
1618
1619 bool
1620 stap_static_probe_ops::is_linespec (const char **linespecp) const
1621 {
1622   static const char *const keywords[] = { "-pstap", "-probe-stap", NULL };
1623
1624   return probe_is_linespec_by_keyword (linespecp, keywords);
1625 }
1626
1627 /* Implementation of the 'get_probes' method.  */
1628
1629 void
1630 stap_static_probe_ops::get_probes
1631   (std::vector<std::unique_ptr<probe>> *probesp,
1632    struct objfile *objfile) const
1633 {
1634   /* If we are here, then this is the first time we are parsing the
1635      SystemTap probe's information.  We basically have to count how many
1636      probes the objfile has, and then fill in the necessary information
1637      for each one.  */
1638   bfd *obfd = objfile->obfd;
1639   bfd_vma base;
1640   struct sdt_note *iter;
1641   unsigned save_probesp_len = probesp->size ();
1642
1643   if (objfile->separate_debug_objfile_backlink != NULL)
1644     {
1645       /* This is a .debug file, not the objfile itself.  */
1646       return;
1647     }
1648
1649   if (elf_tdata (obfd)->sdt_note_head == NULL)
1650     {
1651       /* There isn't any probe here.  */
1652       return;
1653     }
1654
1655   if (!get_stap_base_address (obfd, &base))
1656     {
1657       /* There was an error finding the base address for the section.
1658          Just return NULL.  */
1659       return;
1660     }
1661
1662   /* Parsing each probe's information.  */
1663   for (iter = elf_tdata (obfd)->sdt_note_head;
1664        iter != NULL;
1665        iter = iter->next)
1666     {
1667       /* We first have to handle all the information about the
1668          probe which is present in the section.  */
1669       handle_stap_probe (objfile, iter, probesp, base);
1670     }
1671
1672   if (save_probesp_len == probesp->size ())
1673     {
1674       /* If we are here, it means we have failed to parse every known
1675          probe.  */
1676       complaint (_("could not parse SystemTap probe(s) from inferior"));
1677       return;
1678     }
1679 }
1680
1681 /* Implementation of the type_name method.  */
1682
1683 const char *
1684 stap_static_probe_ops::type_name () const
1685 {
1686   return "stap";
1687 }
1688
1689 /* Implementation of the 'gen_info_probes_table_header' method.  */
1690
1691 std::vector<struct info_probe_column>
1692 stap_static_probe_ops::gen_info_probes_table_header () const
1693 {
1694   struct info_probe_column stap_probe_column;
1695
1696   stap_probe_column.field_name = "semaphore";
1697   stap_probe_column.print_name = _("Semaphore");
1698
1699   return std::vector<struct info_probe_column> { stap_probe_column };
1700 }
1701
1702 /* Implementation of the `info probes stap' command.  */
1703
1704 static void
1705 info_probes_stap_command (const char *arg, int from_tty)
1706 {
1707   info_probes_for_spops (arg, from_tty, &stap_static_probe_ops);
1708 }
1709
1710 void
1711 _initialize_stap_probe (void)
1712 {
1713   all_static_probe_ops.push_back (&stap_static_probe_ops);
1714
1715   add_setshow_zuinteger_cmd ("stap-expression", class_maintenance,
1716                              &stap_expression_debug,
1717                              _("Set SystemTap expression debugging."),
1718                              _("Show SystemTap expression debugging."),
1719                              _("When non-zero, the internal representation "
1720                                "of SystemTap expressions will be printed."),
1721                              NULL,
1722                              show_stapexpressiondebug,
1723                              &setdebuglist, &showdebuglist);
1724
1725   add_cmd ("stap", class_info, info_probes_stap_command,
1726            _("\
1727 Show information about SystemTap static probes.\n\
1728 Usage: info probes stap [PROVIDER [NAME [OBJECT]]]\n\
1729 Each argument is a regular expression, used to select probes.\n\
1730 PROVIDER matches probe provider names.\n\
1731 NAME matches the probe names.\n\
1732 OBJECT matches the executable or shared library name."),
1733            info_probes_cmdlist_get ());
1734
1735 }