gdb/stap-probe.c

   1 /* SystemTap probe support for GDB.
   2
   3    Copyright (C) 2012 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 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, struct objfile *objfile)
 907 {
 908   const char *cur;
 909   struct gdbarch *gdbarch = get_objfile_arch (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                                struct objfile *objfile)
 996 {
 997   struct stap_probe *probe = (struct stap_probe *) probe_generic;
 998
 999   gdb_assert (probe_generic->pops == &stap_probe_ops);
1000
1001   if (!probe->args_parsed)
1002     stap_parse_probe_arguments (probe, objfile);
1003
1004   gdb_assert (probe->args_parsed);
1005   return VEC_length (stap_probe_arg_s, probe->args_u.vec);
1006 }
1007
1008 /* Return 1 if OP is a valid operator inside a probe argument, or zero
1009    otherwise.  */
1010
1011 static int
1012 stap_is_operator (const char *op)
1013 {
1014   int ret = 1;
1015
1016   switch (*op)
1017     {
1018     case '*':
1019     case '/':
1020     case '%':
1021     case '^':
1022     case '!':
1023     case '+':
1024     case '-':
1025     case '<':
1026     case '>':
1027     case '|':
1028     case '&':
1029       break;
1030
1031     case '=':
1032       if (op[1] != '=')
1033         ret = 0;
1034       break;
1035
1036     default:
1037       /* We didn't find any operator.  */
1038       ret = 0;
1039     }
1040
1041   return ret;
1042 }
1043
1044 static struct stap_probe_arg *
1045 stap_get_arg (struct stap_probe *probe, struct objfile *objfile, unsigned n)
1046 {
1047   if (!probe->args_parsed)
1048     stap_parse_probe_arguments (probe, objfile);
1049
1050   return VEC_index (stap_probe_arg_s, probe->args_u.vec, n);
1051 }
1052
1053 /* Evaluate the probe's argument N (indexed from 0), returning a value
1054    corresponding to it.  Assertion is thrown if N does not exist.  */
1055
1056 static struct value *
1057 stap_evaluate_probe_argument (struct probe *probe_generic,
1058                               struct objfile *objfile, unsigned n)
1059 {
1060   struct stap_probe *stap_probe = (struct stap_probe *) probe_generic;
1061   struct stap_probe_arg *arg;
1062   int pos = 0;
1063
1064   gdb_assert (probe_generic->pops == &stap_probe_ops);
1065
1066   arg = stap_get_arg (stap_probe, objfile, n);
1067   return evaluate_subexp_standard (arg->atype, arg->aexpr, &pos, EVAL_NORMAL);
1068 }
1069
1070 /* Compile the probe's argument N (indexed from 0) to agent expression.
1071    Assertion is thrown if N does not exist.  */
1072
1073 static void
1074 stap_compile_to_ax (struct probe *probe_generic, struct objfile *objfile,
1075                     struct agent_expr *expr, struct axs_value *value,
1076                     unsigned n)
1077 {
1078   struct stap_probe *stap_probe = (struct stap_probe *) probe_generic;
1079   struct stap_probe_arg *arg;
1080   union exp_element *pc;
1081
1082   gdb_assert (probe_generic->pops == &stap_probe_ops);
1083
1084   arg = stap_get_arg (stap_probe, objfile, n);
1085
1086   pc = arg->aexpr->elts;
1087   gen_expr (arg->aexpr, &pc, expr, value);
1088
1089   require_rvalue (expr, value);
1090   value->type = arg->atype;
1091 }
1092
1093 /* Destroy (free) the data related to PROBE.  PROBE memory itself is not feed
1094    as it is allocated from OBJFILE_OBSTACK.  */
1095
1096 static void
1097 stap_probe_destroy (struct probe *probe_generic)
1098 {
1099   struct stap_probe *probe = (struct stap_probe *) probe_generic;
1100
1101   gdb_assert (probe_generic->pops == &stap_probe_ops);
1102
1103   if (probe->args_parsed)
1104     {
1105       struct stap_probe_arg *arg;
1106       int ix;
1107
1108       for (ix = 0; VEC_iterate (stap_probe_arg_s, probe->args_u.vec, ix, arg);
1109            ++ix)
1110         xfree (arg->aexpr);
1111       VEC_free (stap_probe_arg_s, probe->args_u.vec);
1112     }
1113 }
1114
1115 \f
1116
1117 /* This is called to compute the value of one of the $_probe_arg*
1118    convenience variables.  */
1119
1120 static struct value *
1121 compute_probe_arg (struct gdbarch *arch, struct internalvar *ivar,
1122                    void *data)
1123 {
1124   struct frame_info *frame = get_selected_frame (_("No frame selected"));
1125   CORE_ADDR pc = get_frame_pc (frame);
1126   int sel = (int) (uintptr_t) data;
1127   struct objfile *objfile;
1128   struct probe *pc_probe;
1129   unsigned n_args;
1130
1131   /* SEL == -1 means "_probe_argc".  */
1132   gdb_assert (sel >= -1);
1133
1134   pc_probe = find_probe_by_pc (pc, &objfile);
1135   if (pc_probe == NULL)
1136     error (_("No SystemTap probe at PC %s"), core_addr_to_string (pc));
1137
1138   n_args
1139     = objfile->sf->sym_probe_fns->sym_get_probe_argument_count (objfile,
1140                                                                 pc_probe);
1141   if (sel == -1)
1142     return value_from_longest (builtin_type (arch)->builtin_int, n_args);
1143
1144   if (sel >= n_args)
1145     error (_("Invalid probe argument %d -- probe has %u arguments available"),
1146            sel, n_args);
1147
1148   return objfile->sf->sym_probe_fns->sym_evaluate_probe_argument (objfile,
1149                                                                   pc_probe,
1150                                                                   sel);
1151 }
1152
1153 /* This is called to compile one of the $_probe_arg* convenience
1154    variables into an agent expression.  */
1155
1156 static void
1157 compile_probe_arg (struct internalvar *ivar, struct agent_expr *expr,
1158                    struct axs_value *value, void *data)
1159 {
1160   CORE_ADDR pc = expr->scope;
1161   int sel = (int) (uintptr_t) data;
1162   struct objfile *objfile;
1163   struct probe *pc_probe;
1164   int n_probes;
1165
1166   /* SEL == -1 means "_probe_argc".  */
1167   gdb_assert (sel >= -1);
1168
1169   pc_probe = find_probe_by_pc (pc, &objfile);
1170   if (pc_probe == NULL)
1171     error (_("No SystemTap probe at PC %s"), core_addr_to_string (pc));
1172
1173   n_probes
1174     = objfile->sf->sym_probe_fns->sym_get_probe_argument_count (objfile,
1175                                                                 pc_probe);
1176   if (sel == -1)
1177     {
1178       value->kind = axs_rvalue;
1179       value->type = builtin_type (expr->gdbarch)->builtin_int;
1180       ax_const_l (expr, n_probes);
1181       return;
1182     }
1183
1184   gdb_assert (sel >= 0);
1185   if (sel >= n_probes)
1186     error (_("Invalid probe argument %d -- probe has %d arguments available"),
1187            sel, n_probes);
1188
1189   objfile->sf->sym_probe_fns->sym_compile_to_ax (objfile, pc_probe,
1190                                                  expr, value, sel);
1191 }
1192
1193 \f
1194
1195 /* Set or clear a SystemTap semaphore.  ADDRESS is the semaphore's
1196    address.  SET is zero if the semaphore should be cleared, or one
1197    if it should be set.  This is a helper function for `stap_semaphore_down'
1198    and `stap_semaphore_up'.  */
1199
1200 static void
1201 stap_modify_semaphore (CORE_ADDR address, int set, struct gdbarch *gdbarch)
1202 {
1203   gdb_byte bytes[sizeof (LONGEST)];
1204   /* The ABI specifies "unsigned short".  */
1205   struct type *type = builtin_type (gdbarch)->builtin_unsigned_short;
1206   ULONGEST value;
1207
1208   if (address == 0)
1209     return;
1210
1211   /* Swallow errors.  */
1212   if (target_read_memory (address, bytes, TYPE_LENGTH (type)) != 0)
1213     {
1214       warning (_("Could not read the value of a SystemTap semaphore."));
1215       return;
1216     }
1217
1218   value = extract_unsigned_integer (bytes, TYPE_LENGTH (type),
1219                                     gdbarch_byte_order (gdbarch));
1220   /* Note that we explicitly don't worry about overflow or
1221      underflow.  */
1222   if (set)
1223     ++value;
1224   else
1225     --value;
1226
1227   store_unsigned_integer (bytes, TYPE_LENGTH (type),
1228                           gdbarch_byte_order (gdbarch), value);
1229
1230   if (target_write_memory (address, bytes, TYPE_LENGTH (type)) != 0)
1231     warning (_("Could not write the value of a SystemTap semaphore."));
1232 }
1233
1234 /* Set a SystemTap semaphore.  SEM is the semaphore's address.  Semaphores
1235    act as reference counters, so calls to this function must be paired with
1236    calls to `stap_semaphore_down'.
1237
1238    This function and `stap_semaphore_down' race with another tool changing
1239    the probes, but that is too rare to care.  */
1240
1241 static void
1242 stap_set_semaphore (struct probe *probe_generic, struct gdbarch *gdbarch)
1243 {
1244   struct stap_probe *probe = (struct stap_probe *) probe_generic;
1245
1246   gdb_assert (probe_generic->pops == &stap_probe_ops);
1247
1248   stap_modify_semaphore (probe->sem_addr, 1, gdbarch);
1249 }
1250
1251 /* Clear a SystemTap semaphore.  SEM is the semaphore's address.  */
1252
1253 static void
1254 stap_clear_semaphore (struct probe *probe_generic, struct gdbarch *gdbarch)
1255 {
1256   struct stap_probe *probe = (struct stap_probe *) probe_generic;
1257
1258   gdb_assert (probe_generic->pops == &stap_probe_ops);
1259
1260   stap_modify_semaphore (probe->sem_addr, 0, gdbarch);
1261 }
1262
1263 /* Implementation of `$_probe_arg*' set of variables.  */
1264
1265 static const struct internalvar_funcs probe_funcs =
1266 {
1267   compute_probe_arg,
1268   compile_probe_arg,
1269   NULL
1270 };
1271
1272 /* Helper function that parses the information contained in a
1273    SystemTap's probe.  Basically, the information consists in:
1274
1275    - Probe's PC address;
1276    - Link-time section address of `.stapsdt.base' section;
1277    - Link-time address of the semaphore variable, or ZERO if the
1278      probe doesn't have an associated semaphore;
1279    - Probe's provider name;
1280    - Probe's name;
1281    - Probe's argument format
1282
1283    This function returns 1 if the handling was successful, and zero
1284    otherwise.  */
1285
1286 static void
1287 handle_stap_probe (struct objfile *objfile, struct sdt_note *el,
1288                    VEC (probe_p) **probesp, CORE_ADDR base)
1289 {
1290   bfd *abfd = objfile->obfd;
1291   int size = bfd_get_arch_size (abfd) / 8;
1292   struct gdbarch *gdbarch = get_objfile_arch (objfile);
1293   struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
1294   CORE_ADDR base_ref;
1295   const char *probe_args = NULL;
1296   struct stap_probe *ret;
1297
1298   ret = obstack_alloc (&objfile->objfile_obstack, sizeof (*ret));
1299   ret->p.pops = &stap_probe_ops;
1300
1301   /* Provider and the name of the probe.  */
1302   ret->p.provider = &el->data[3 * size];
1303   ret->p.name = memchr (ret->p.provider, '\0',
1304                         (char *) el->data + el->size - ret->p.provider);
1305   /* Making sure there is a name.  */
1306   if (!ret->p.name)
1307     {
1308       complaint (&symfile_complaints, _("corrupt probe name when "
1309                                         "reading `%s'"), objfile->name);
1310
1311       /* There is no way to use a probe without a name or a provider, so
1312          returning zero here makes sense.  */
1313       return;
1314     }
1315   else
1316     ++ret->p.name;
1317
1318   /* Retrieving the probe's address.  */
1319   ret->p.address = extract_typed_address (&el->data[0], ptr_type);
1320
1321   /* Link-time sh_addr of `.stapsdt.base' section.  */
1322   base_ref = extract_typed_address (&el->data[size], ptr_type);
1323
1324   /* Semaphore address.  */
1325   ret->sem_addr = extract_typed_address (&el->data[2 * size], ptr_type);
1326
1327   ret->p.address += (ANOFFSET (objfile->section_offsets,
1328                                SECT_OFF_TEXT (objfile))
1329                      + base - base_ref);
1330   if (ret->sem_addr)
1331     ret->sem_addr += (ANOFFSET (objfile->section_offsets,
1332                                 SECT_OFF_DATA (objfile))
1333                       + base - base_ref);
1334
1335   /* Arguments.  We can only extract the argument format if there is a valid
1336      name for this probe.  */
1337   probe_args = memchr (ret->p.name, '\0',
1338                        (char *) el->data + el->size - ret->p.name);
1339
1340   if (probe_args != NULL)
1341     ++probe_args;
1342
1343   if (probe_args == NULL || (memchr (probe_args, '\0',
1344                                      (char *) el->data + el->size - ret->p.name)
1345                              != el->data + el->size - 1))
1346     {
1347       complaint (&symfile_complaints, _("corrupt probe argument when "
1348                                         "reading `%s'"), objfile->name);
1349       /* If the argument string is NULL, it means some problem happened with
1350          it.  So we return 0.  */
1351       return;
1352     }
1353
1354   ret->args_parsed = 0;
1355   ret->args_u.text = (void *) probe_args;
1356
1357   /* Successfully created probe.  */
1358   VEC_safe_push (probe_p, *probesp, (struct probe *) ret);
1359 }
1360
1361 /* Helper function which tries to find the base address of the SystemTap
1362    base section named STAP_BASE_SECTION_NAME.  */
1363
1364 static void
1365 get_stap_base_address_1 (bfd *abfd, asection *sect, void *obj)
1366 {
1367   asection **ret = obj;
1368
1369   if ((sect->flags & (SEC_DATA | SEC_ALLOC | SEC_HAS_CONTENTS))
1370       && sect->name && !strcmp (sect->name, STAP_BASE_SECTION_NAME))
1371     *ret = sect;
1372 }
1373
1374 /* Helper function which iterates over every section in the BFD file,
1375    trying to find the base address of the SystemTap base section.
1376    Returns 1 if found (setting BASE to the proper value), zero otherwise.  */
1377
1378 static int
1379 get_stap_base_address (bfd *obfd, bfd_vma *base)
1380 {
1381   asection *ret = NULL;
1382
1383   bfd_map_over_sections (obfd, get_stap_base_address_1, (void *) &ret);
1384
1385   if (!ret)
1386     {
1387       complaint (&symfile_complaints, _("could not obtain base address for "
1388                                         "SystemTap section on objfile `%s'."),
1389                  obfd->filename);
1390       return 0;
1391     }
1392
1393   if (base)
1394     *base = ret->vma;
1395
1396   return 1;
1397 }
1398
1399 /* Helper function for `elf_get_probes', which gathers information about all
1400    SystemTap probes from OBJFILE.  */
1401
1402 static void
1403 stap_get_probes (VEC (probe_p) **probesp, struct objfile *objfile)
1404 {
1405   /* If we are here, then this is the first time we are parsing the
1406      SystemTap probe's information.  We basically have to count how many
1407      probes the objfile has, and then fill in the necessary information
1408      for each one.  */
1409   bfd *obfd = objfile->obfd;
1410   bfd_vma base;
1411   struct sdt_note *iter;
1412   unsigned save_probesp_len = VEC_length (probe_p, *probesp);
1413
1414   if (objfile->separate_debug_objfile_backlink != NULL)
1415     {
1416       /* This is a .debug file, not the objfile itself.  */
1417       return;
1418     }
1419
1420   if (!elf_tdata (obfd)->sdt_note_head)
1421     {
1422       /* There isn't any probe here.  */
1423       return;
1424     }
1425
1426   if (!get_stap_base_address (obfd, &base))
1427     {
1428       /* There was an error finding the base address for the section.
1429          Just return NULL.  */
1430       return;
1431     }
1432
1433   /* Parsing each probe's information.  */
1434   for (iter = elf_tdata (obfd)->sdt_note_head; iter; iter = iter->next)
1435     {
1436       /* We first have to handle all the information about the
1437          probe which is present in the section.  */
1438       handle_stap_probe (objfile, iter, probesp, base);
1439     }
1440
1441   if (save_probesp_len == VEC_length (probe_p, *probesp))
1442     {
1443       /* If we are here, it means we have failed to parse every known
1444          probe.  */
1445       complaint (&symfile_complaints, _("could not parse SystemTap probe(s) "
1446                                         "from inferior"));
1447       return;
1448     }
1449 }
1450
1451 static void
1452 stap_relocate (struct probe *probe_generic, CORE_ADDR delta)
1453 {
1454   struct stap_probe *probe = (struct stap_probe *) probe_generic;
1455
1456   gdb_assert (probe_generic->pops == &stap_probe_ops);
1457
1458   probe->p.address += delta;
1459   if (probe->sem_addr)
1460     probe->sem_addr += delta;
1461 }
1462
1463 static int
1464 stap_probe_is_linespec (const char **linespecp)
1465 {
1466   static const char *const keywords[] = { "-pstap", "-probe-stap", NULL };
1467
1468   return probe_is_linespec_by_keyword (linespecp, keywords);
1469 }
1470
1471 static void
1472 stap_gen_info_probes_table_header (VEC (info_probe_column_s) **heads)
1473 {
1474   info_probe_column_s stap_probe_column;
1475
1476   stap_probe_column.field_name = "semaphore";
1477   stap_probe_column.print_name = _("Semaphore");
1478
1479   VEC_safe_push (info_probe_column_s, *heads, &stap_probe_column);
1480 }
1481
1482 static void
1483 stap_gen_info_probes_table_values (struct probe *probe_generic,
1484                                    struct objfile *objfile,
1485                                    VEC (const_char_ptr) **ret)
1486 {
1487   struct stap_probe *probe = (struct stap_probe *) probe_generic;
1488   struct gdbarch *gdbarch = get_objfile_arch (objfile);
1489   const char *val = NULL;
1490
1491   gdb_assert (probe_generic->pops == &stap_probe_ops);
1492
1493   if (probe->sem_addr)
1494     val = print_core_address (gdbarch, probe->sem_addr);
1495
1496   VEC_safe_push (const_char_ptr, *ret, val);
1497 }
1498
1499 /* SystemTap probe_ops.  */
1500
1501 static const struct probe_ops stap_probe_ops =
1502 {
1503   stap_probe_is_linespec,
1504   stap_get_probes,
1505   stap_relocate,
1506   stap_get_probe_argument_count,
1507   stap_evaluate_probe_argument,
1508   stap_compile_to_ax,
1509   stap_set_semaphore,
1510   stap_clear_semaphore,
1511   stap_probe_destroy,
1512   stap_gen_info_probes_table_header,
1513   stap_gen_info_probes_table_values,
1514 };
1515
1516 /* Implementation of the `info probes stap' command.  */
1517
1518 static void
1519 info_probes_stap_command (char *arg, int from_tty)
1520 {
1521   info_probes_for_ops (arg, from_tty, &stap_probe_ops);
1522 }
1523
1524 void _initialize_stap_probe (void);
1525
1526 void
1527 _initialize_stap_probe (void)
1528 {
1529   VEC_safe_push (probe_ops_cp, all_probe_ops, &stap_probe_ops);
1530
1531   add_setshow_zinteger_cmd ("stap-expression", class_maintenance,
1532                             &stap_expression_debug,
1533                             _("Set SystemTap expression debugging."),
1534                             _("Show SystemTap expression debugging."),
1535                             _("When non-zero, the internal representation "
1536                               "of SystemTap expressions will be printed."),
1537                             NULL,
1538                             show_stapexpressiondebug,
1539                             &setdebuglist, &showdebuglist);
1540
1541   create_internalvar_type_lazy ("_probe_argc", &probe_funcs,
1542                                 (void *) (uintptr_t) -1);
1543   create_internalvar_type_lazy ("_probe_arg0", &probe_funcs,
1544                                 (void *) (uintptr_t) 0);
1545   create_internalvar_type_lazy ("_probe_arg1", &probe_funcs,
1546                                 (void *) (uintptr_t) 1);
1547   create_internalvar_type_lazy ("_probe_arg2", &probe_funcs,
1548                                 (void *) (uintptr_t) 2);
1549   create_internalvar_type_lazy ("_probe_arg3", &probe_funcs,
1550                                 (void *) (uintptr_t) 3);
1551   create_internalvar_type_lazy ("_probe_arg4", &probe_funcs,
1552                                 (void *) (uintptr_t) 4);
1553   create_internalvar_type_lazy ("_probe_arg5", &probe_funcs,
1554                                 (void *) (uintptr_t) 5);
1555   create_internalvar_type_lazy ("_probe_arg6", &probe_funcs,
1556                                 (void *) (uintptr_t) 6);
1557   create_internalvar_type_lazy ("_probe_arg7", &probe_funcs,
1558                                 (void *) (uintptr_t) 7);
1559   create_internalvar_type_lazy ("_probe_arg8", &probe_funcs,
1560                                 (void *) (uintptr_t) 8);
1561   create_internalvar_type_lazy ("_probe_arg9", &probe_funcs,
1562                                 (void *) (uintptr_t) 9);
1563   create_internalvar_type_lazy ("_probe_arg10", &probe_funcs,
1564                                 (void *) (uintptr_t) 10);
1565   create_internalvar_type_lazy ("_probe_arg11", &probe_funcs,
1566                                 (void *) (uintptr_t) 11);
1567
1568   add_cmd ("stap", class_info, info_probes_stap_command,
1569            _("\
1570 Show information about SystemTap static probes.\n\
1571 Usage: info probes stap [PROVIDER [NAME [OBJECT]]]\n\
1572 Each argument is a regular expression, used to select probes.\n\
1573 PROVIDER matches probe provider names.\n\
1574 NAME matches the probe names.\n\
1575 OBJECT matches the executable or shared library name."),
1576            info_probes_cmdlist_get ());
1577
1578 }