contrib/gdb-7/gdb/stap-probe.c

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