gdb/location.c

   1 /* Data structures and API for event locations in GDB.
   2    Copyright (C) 2013-2018 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19 #include "defs.h"
  20 #include "gdb_assert.h"
  21 #include "location.h"
  22 #include "symtab.h"
  23 #include "language.h"
  24 #include "linespec.h"
  25 #include "cli/cli-utils.h"
  26 #include "probe.h"
  27 #include "cp-support.h"
  28
  29 #include <ctype.h>
  30 #include <string.h>
  31
  32 /* An event location used to set a stop event in the inferior.
  33    This structure is an amalgam of the various ways
  34    to specify where a stop event should be set.  */
  35
  36 struct event_location
  37 {
  38   /* The type of this breakpoint specification.  */
  39   enum event_location_type type;
  40 #define EL_TYPE(P) (P)->type
  41
  42   union
  43   {
  44     /* A probe.  */
  45     char *addr_string;
  46 #define EL_PROBE(P) ((P)->u.addr_string)
  47
  48     /* A "normal" linespec.  */
  49     struct linespec_location linespec_location;
  50 #define EL_LINESPEC(P) (&(P)->u.linespec_location)
  51
  52     /* An address in the inferior.  */
  53     CORE_ADDR address;
  54 #define EL_ADDRESS(P) (P)->u.address
  55
  56     /* An explicit location.  */
  57     struct explicit_location explicit_loc;
  58 #define EL_EXPLICIT(P) (&((P)->u.explicit_loc))
  59   } u;
  60
  61   /* Cached string representation of this location.  This is used, e.g., to
  62      save stop event locations to file.  Malloc'd.  */
  63   char *as_string;
  64 #define EL_STRING(P) ((P)->as_string)
  65 };
  66
  67 /* See description in location.h.  */
  68
  69 enum event_location_type
  70 event_location_type (const struct event_location *location)
  71 {
  72   return EL_TYPE (location);
  73 }
  74
  75 /* See description in location.h.  */
  76
  77 void
  78 initialize_explicit_location (struct explicit_location *explicit_loc)
  79 {
  80   memset (explicit_loc, 0, sizeof (struct explicit_location));
  81   explicit_loc->line_offset.sign = LINE_OFFSET_UNKNOWN;
  82   explicit_loc->func_name_match_type = symbol_name_match_type::WILD;
  83 }
  84
  85 /* See description in location.h.  */
  86
  87 event_location_up
  88 new_linespec_location (const char **linespec,
  89                        symbol_name_match_type match_type)
  90 {
  91   struct event_location *location;
  92
  93   location = XCNEW (struct event_location);
  94   EL_TYPE (location) = LINESPEC_LOCATION;
  95   EL_LINESPEC (location)->match_type = match_type;
  96   if (*linespec != NULL)
  97     {
  98       const char *p;
  99       const char *orig = *linespec;
 100
 101       linespec_lex_to_end (linespec);
 102       p = remove_trailing_whitespace (orig, *linespec);
 103       if ((p - orig) > 0)
 104         EL_LINESPEC (location)->spec_string = savestring (orig, p - orig);
 105     }
 106   return event_location_up (location);
 107 }
 108
 109 /* See description in location.h.  */
 110
 111 const linespec_location *
 112 get_linespec_location (const struct event_location *location)
 113 {
 114   gdb_assert (EL_TYPE (location) == LINESPEC_LOCATION);
 115   return EL_LINESPEC (location);
 116 }
 117
 118 /* See description in location.h.  */
 119
 120 event_location_up
 121 new_address_location (CORE_ADDR addr, const char *addr_string,
 122                       int addr_string_len)
 123 {
 124   struct event_location *location;
 125
 126   location = XCNEW (struct event_location);
 127   EL_TYPE (location) = ADDRESS_LOCATION;
 128   EL_ADDRESS (location) = addr;
 129   if (addr_string != NULL)
 130     EL_STRING (location) = xstrndup (addr_string, addr_string_len);
 131   return event_location_up (location);
 132 }
 133
 134 /* See description in location.h.  */
 135
 136 CORE_ADDR
 137 get_address_location (const struct event_location *location)
 138 {
 139   gdb_assert (EL_TYPE (location) == ADDRESS_LOCATION);
 140   return EL_ADDRESS (location);
 141 }
 142
 143 /* See description in location.h.  */
 144
 145 const char *
 146 get_address_string_location (const struct event_location *location)
 147 {
 148   gdb_assert (EL_TYPE (location) == ADDRESS_LOCATION);
 149   return EL_STRING (location);
 150 }
 151
 152 /* See description in location.h.  */
 153
 154 event_location_up
 155 new_probe_location (const char *probe)
 156 {
 157   struct event_location *location;
 158
 159   location = XCNEW (struct event_location);
 160   EL_TYPE (location) = PROBE_LOCATION;
 161   if (probe != NULL)
 162     EL_PROBE (location) = xstrdup (probe);
 163   return event_location_up (location);
 164 }
 165
 166 /* See description in location.h.  */
 167
 168 const char *
 169 get_probe_location (const struct event_location *location)
 170 {
 171   gdb_assert (EL_TYPE (location) == PROBE_LOCATION);
 172   return EL_PROBE (location);
 173 }
 174
 175 /* See description in location.h.  */
 176
 177 event_location_up
 178 new_explicit_location (const struct explicit_location *explicit_loc)
 179 {
 180   struct event_location tmp;
 181
 182   memset (&tmp, 0, sizeof (struct event_location));
 183   EL_TYPE (&tmp) = EXPLICIT_LOCATION;
 184   initialize_explicit_location (EL_EXPLICIT (&tmp));
 185   if (explicit_loc != NULL)
 186     {
 187       EL_EXPLICIT (&tmp)->func_name_match_type
 188         = explicit_loc->func_name_match_type;
 189
 190       if (explicit_loc->source_filename != NULL)
 191         {
 192           EL_EXPLICIT (&tmp)->source_filename
 193             = explicit_loc->source_filename;
 194         }
 195
 196       if (explicit_loc->function_name != NULL)
 197         EL_EXPLICIT (&tmp)->function_name
 198           = explicit_loc->function_name;
 199
 200       if (explicit_loc->label_name != NULL)
 201         EL_EXPLICIT (&tmp)->label_name = explicit_loc->label_name;
 202
 203       if (explicit_loc->line_offset.sign != LINE_OFFSET_UNKNOWN)
 204         EL_EXPLICIT (&tmp)->line_offset = explicit_loc->line_offset;
 205     }
 206
 207   return copy_event_location (&tmp);
 208 }
 209
 210 /* See description in location.h.  */
 211
 212 struct explicit_location *
 213 get_explicit_location (struct event_location *location)
 214 {
 215   gdb_assert (EL_TYPE (location) == EXPLICIT_LOCATION);
 216   return EL_EXPLICIT (location);
 217 }
 218
 219 /* See description in location.h.  */
 220
 221 const struct explicit_location *
 222 get_explicit_location_const (const struct event_location *location)
 223 {
 224   gdb_assert (EL_TYPE (location) == EXPLICIT_LOCATION);
 225   return EL_EXPLICIT (location);
 226 }
 227
 228 /* This convenience function returns a malloc'd string which
 229    represents the location in EXPLICIT_LOC.
 230
 231    AS_LINESPEC is non-zero if this string should be a linespec.
 232    Otherwise it will be output in explicit form.  */
 233
 234 static char *
 235 explicit_to_string_internal (int as_linespec,
 236                              const struct explicit_location *explicit_loc)
 237 {
 238   int need_space = 0;
 239   char space = as_linespec ? ':' : ' ';
 240   string_file buf;
 241
 242   if (explicit_loc->source_filename != NULL)
 243     {
 244       if (!as_linespec)
 245         buf.puts ("-source ");
 246       buf.puts (explicit_loc->source_filename);
 247       need_space = 1;
 248     }
 249
 250   if (explicit_loc->function_name != NULL)
 251     {
 252       if (need_space)
 253         buf.putc (space);
 254       if (explicit_loc->func_name_match_type == symbol_name_match_type::FULL)
 255         buf.puts ("-qualified ");
 256       if (!as_linespec)
 257         buf.puts ("-function ");
 258       buf.puts (explicit_loc->function_name);
 259       need_space = 1;
 260     }
 261
 262   if (explicit_loc->label_name != NULL)
 263     {
 264       if (need_space)
 265         buf.putc (space);
 266       if (!as_linespec)
 267         buf.puts ("-label ");
 268       buf.puts (explicit_loc->label_name);
 269       need_space = 1;
 270     }
 271
 272   if (explicit_loc->line_offset.sign != LINE_OFFSET_UNKNOWN)
 273     {
 274       if (need_space)
 275         buf.putc (space);
 276       if (!as_linespec)
 277         buf.puts ("-line ");
 278       buf.printf ("%s%d",
 279                   (explicit_loc->line_offset.sign == LINE_OFFSET_NONE ? ""
 280                    : (explicit_loc->line_offset.sign
 281                       == LINE_OFFSET_PLUS ? "+" : "-")),
 282                   explicit_loc->line_offset.offset);
 283     }
 284
 285   return xstrdup (buf.c_str ());
 286 }
 287
 288 /* See description in location.h.  */
 289
 290 char *
 291 explicit_location_to_string (const struct explicit_location *explicit_loc)
 292 {
 293   return explicit_to_string_internal (0, explicit_loc);
 294 }
 295
 296 /* See description in location.h.  */
 297
 298 char *
 299 explicit_location_to_linespec (const struct explicit_location *explicit_loc)
 300 {
 301   return explicit_to_string_internal (1, explicit_loc);
 302 }
 303
 304 /* See description in location.h.  */
 305
 306 event_location_up
 307 copy_event_location (const struct event_location *src)
 308 {
 309   struct event_location *dst;
 310
 311   dst = XCNEW (struct event_location);
 312   EL_TYPE (dst) = EL_TYPE (src);
 313   if (EL_STRING (src) != NULL)
 314     EL_STRING (dst) = xstrdup (EL_STRING (src));
 315
 316   switch (EL_TYPE (src))
 317     {
 318     case LINESPEC_LOCATION:
 319       EL_LINESPEC (dst)->match_type = EL_LINESPEC (src)->match_type;
 320       if (EL_LINESPEC (src)->spec_string != NULL)
 321         EL_LINESPEC (dst)->spec_string
 322           = xstrdup (EL_LINESPEC (src)->spec_string);
 323       break;
 324
 325     case ADDRESS_LOCATION:
 326       EL_ADDRESS (dst) = EL_ADDRESS (src);
 327       break;
 328
 329     case EXPLICIT_LOCATION:
 330       EL_EXPLICIT (dst)->func_name_match_type
 331         = EL_EXPLICIT (src)->func_name_match_type;
 332       if (EL_EXPLICIT (src)->source_filename != NULL)
 333         EL_EXPLICIT (dst)->source_filename
 334           = xstrdup (EL_EXPLICIT (src)->source_filename);
 335
 336       if (EL_EXPLICIT (src)->function_name != NULL)
 337         EL_EXPLICIT (dst)->function_name
 338           = xstrdup (EL_EXPLICIT (src)->function_name);
 339
 340       if (EL_EXPLICIT (src)->label_name != NULL)
 341         EL_EXPLICIT (dst)->label_name = xstrdup (EL_EXPLICIT (src)->label_name);
 342
 343       EL_EXPLICIT (dst)->line_offset = EL_EXPLICIT (src)->line_offset;
 344       break;
 345
 346
 347     case PROBE_LOCATION:
 348       if (EL_PROBE (src) != NULL)
 349         EL_PROBE (dst) = xstrdup (EL_PROBE (src));
 350       break;
 351
 352     default:
 353       gdb_assert_not_reached ("unknown event location type");
 354     }
 355
 356   return event_location_up (dst);
 357 }
 358
 359 void
 360 event_location_deleter::operator() (event_location *location) const
 361 {
 362   if (location != NULL)
 363     {
 364       xfree (EL_STRING (location));
 365
 366       switch (EL_TYPE (location))
 367         {
 368         case LINESPEC_LOCATION:
 369           xfree (EL_LINESPEC (location)->spec_string);
 370           break;
 371
 372         case ADDRESS_LOCATION:
 373           /* Nothing to do.  */
 374           break;
 375
 376         case EXPLICIT_LOCATION:
 377           xfree (EL_EXPLICIT (location)->source_filename);
 378           xfree (EL_EXPLICIT (location)->function_name);
 379           xfree (EL_EXPLICIT (location)->label_name);
 380           break;
 381
 382         case PROBE_LOCATION:
 383           xfree (EL_PROBE (location));
 384           break;
 385
 386         default:
 387           gdb_assert_not_reached ("unknown event location type");
 388         }
 389
 390       xfree (location);
 391     }
 392 }
 393
 394 /* See description in location.h.  */
 395
 396 const char *
 397 event_location_to_string (struct event_location *location)
 398 {
 399   if (EL_STRING (location) == NULL)
 400     {
 401       switch (EL_TYPE (location))
 402         {
 403         case LINESPEC_LOCATION:
 404           if (EL_LINESPEC (location)->spec_string != NULL)
 405             {
 406               linespec_location *ls = EL_LINESPEC (location);
 407               if (ls->match_type == symbol_name_match_type::FULL)
 408                 {
 409                   EL_STRING (location)
 410                     = concat ("-qualified ", ls->spec_string, (char *) NULL);
 411                 }
 412               else
 413                 EL_STRING (location) = xstrdup (ls->spec_string);
 414             }
 415           break;
 416
 417         case ADDRESS_LOCATION:
 418           EL_STRING (location)
 419             = xstrprintf ("*%s",
 420                           core_addr_to_string (EL_ADDRESS (location)));
 421           break;
 422
 423         case EXPLICIT_LOCATION:
 424           EL_STRING (location)
 425             = explicit_location_to_string (EL_EXPLICIT (location));
 426           break;
 427
 428         case PROBE_LOCATION:
 429           EL_STRING (location) = xstrdup (EL_PROBE (location));
 430           break;
 431
 432         default:
 433           gdb_assert_not_reached ("unknown event location type");
 434         }
 435     }
 436
 437   return EL_STRING (location);
 438 }
 439
 440 /* Find an instance of the quote character C in the string S that is
 441    outside of all single- and double-quoted strings (i.e., any quoting
 442    other than C).  */
 443
 444 static const char *
 445 find_end_quote (const char *s, char end_quote_char)
 446 {
 447   /* zero if we're not in quotes;
 448      '"' if we're in a double-quoted string;
 449      '\'' if we're in a single-quoted string.  */
 450   char nested_quote_char = '\0';
 451
 452   for (const char *scan = s; *scan != '\0'; scan++)
 453     {
 454       if (nested_quote_char != '\0')
 455         {
 456           if (*scan == nested_quote_char)
 457             nested_quote_char = '\0';
 458           else if (scan[0] == '\\' && *(scan + 1) != '\0')
 459             scan++;
 460         }
 461       else if (*scan == end_quote_char && nested_quote_char == '\0')
 462         return scan;
 463       else if (*scan == '"' || *scan == '\'')
 464         nested_quote_char = *scan;
 465     }
 466
 467   return 0;
 468 }
 469
 470 /* A lexer for explicit locations.  This function will advance INP
 471    past any strings that it lexes.  Returns a malloc'd copy of the
 472    lexed string or NULL if no lexing was done.  */
 473
 474 static gdb::unique_xmalloc_ptr<char>
 475 explicit_location_lex_one (const char **inp,
 476                            const struct language_defn *language,
 477                            explicit_completion_info *completion_info)
 478 {
 479   const char *start = *inp;
 480
 481   if (*start == '\0')
 482     return NULL;
 483
 484   /* If quoted, skip to the ending quote.  */
 485   if (strchr (get_gdb_linespec_parser_quote_characters (), *start))
 486     {
 487       if (completion_info != NULL)
 488         completion_info->quoted_arg_start = start;
 489
 490       const char *end = find_end_quote (start + 1, *start);
 491
 492       if (end == NULL)
 493         {
 494           if (completion_info == NULL)
 495             error (_("Unmatched quote, %s."), start);
 496
 497           end = start + strlen (start);
 498           *inp = end;
 499           return gdb::unique_xmalloc_ptr<char> (savestring (start + 1,
 500                                                             *inp - start - 1));
 501         }
 502
 503       if (completion_info != NULL)
 504         completion_info->quoted_arg_end = end;
 505       *inp = end + 1;
 506       return gdb::unique_xmalloc_ptr<char> (savestring (start + 1,
 507                                                         *inp - start - 2));
 508     }
 509
 510   /* If the input starts with '-' or '+', the string ends with the next
 511      whitespace or comma.  */
 512   if (*start == '-' || *start == '+')
 513     {
 514       while (*inp[0] != '\0' && *inp[0] != ',' && !isspace (*inp[0]))
 515         ++(*inp);
 516     }
 517   else
 518     {
 519       /* Handle numbers first, stopping at the next whitespace or ','.  */
 520       while (isdigit (*inp[0]))
 521         ++(*inp);
 522       if (*inp[0] == '\0' || isspace (*inp[0]) || *inp[0] == ',')
 523         return gdb::unique_xmalloc_ptr<char> (savestring (start,
 524                                                           *inp - start));
 525
 526       /* Otherwise stop at the next occurrence of whitespace, '\0',
 527          keyword, or ','.  */
 528       *inp = start;
 529       while ((*inp)[0]
 530              && (*inp)[0] != ','
 531              && !(isspace ((*inp)[0])
 532                   || linespec_lexer_lex_keyword (&(*inp)[1])))
 533         {
 534           /* Special case: C++ operator,.  */
 535           if (language->la_language == language_cplus
 536               && startswith (*inp, CP_OPERATOR_STR))
 537             (*inp) += CP_OPERATOR_LEN;
 538           ++(*inp);
 539         }
 540     }
 541
 542   if (*inp - start > 0)
 543     return gdb::unique_xmalloc_ptr<char> (savestring (start, *inp - start));
 544
 545   return NULL;
 546 }
 547
 548 /* Return true if COMMA points past "operator".  START is the start of
 549    the line that COMMAND points to, hence when reading backwards, we
 550    must not read any character before START.  */
 551
 552 static bool
 553 is_cp_operator (const char *start, const char *comma)
 554 {
 555   if (comma != NULL
 556       && (comma - start) >= CP_OPERATOR_LEN)
 557     {
 558       const char *p = comma;
 559
 560       while (p > start && isspace (p[-1]))
 561         p--;
 562       if (p - start >= CP_OPERATOR_LEN)
 563         {
 564           p -= CP_OPERATOR_LEN;
 565           if (strncmp (p, CP_OPERATOR_STR, CP_OPERATOR_LEN) == 0
 566               && (p == start
 567                   || !(isalnum (p[-1]) || p[-1] == '_')))
 568             {
 569               return true;
 570             }
 571         }
 572     }
 573   return false;
 574 }
 575
 576 /* When scanning the input string looking for the next explicit
 577    location option/delimiter, we jump to the next option by looking
 578    for ",", and "-".  Such a character can also appear in C++ symbols
 579    like "operator," and "operator-".  So when we find such a
 580    character, we call this function to check if we found such a
 581    symbol, meaning we had a false positive for an option string.  In
 582    that case, we keep looking for the next delimiter, until we find
 583    one that is not a false positive, or we reach end of string.  FOUND
 584    is the character that scanning found (either '-' or ','), and START
 585    is the start of the line that FOUND points to, hence when reading
 586    backwards, we must not read any character before START.  Returns a
 587    pointer to the next non-false-positive delimiter character, or NULL
 588    if none was found.  */
 589
 590 static const char *
 591 skip_op_false_positives (const char *start, const char *found)
 592 {
 593   while (found != NULL && is_cp_operator (start, found))
 594     {
 595       if (found[0] == '-' && found[1] == '-')
 596         start = found + 2;
 597       else
 598         start = found + 1;
 599       found = find_toplevel_char (start, *found);
 600     }
 601
 602   return found;
 603 }
 604
 605 /* Assuming both FIRST and NEW_TOK point into the same string, return
 606    the pointer that is closer to the start of the string.  If FIRST is
 607    NULL, returns NEW_TOK.  If NEW_TOK is NULL, returns FIRST.  */
 608
 609 static const char *
 610 first_of (const char *first, const char *new_tok)
 611 {
 612   if (first == NULL)
 613     return new_tok;
 614   else if (new_tok != NULL && new_tok < first)
 615     return new_tok;
 616   else
 617     return first;
 618 }
 619
 620 /* A lexer for functions in explicit locations.  This function will
 621    advance INP past a function until the next option, or until end of
 622    string.  Returns a malloc'd copy of the lexed string or NULL if no
 623    lexing was done.  */
 624
 625 static gdb::unique_xmalloc_ptr<char>
 626 explicit_location_lex_one_function (const char **inp,
 627                                     const struct language_defn *language,
 628                                     explicit_completion_info *completion_info)
 629 {
 630   const char *start = *inp;
 631
 632   if (*start == '\0')
 633     return NULL;
 634
 635   /* If quoted, skip to the ending quote.  */
 636   if (strchr (get_gdb_linespec_parser_quote_characters (), *start))
 637     {
 638       char quote_char = *start;
 639
 640       /* If the input is not an Ada operator, skip to the matching
 641          closing quote and return the string.  */
 642       if (!(language->la_language == language_ada
 643             && quote_char == '\"' && is_ada_operator (start)))
 644         {
 645           if (completion_info != NULL)
 646             completion_info->quoted_arg_start = start;
 647
 648           const char *end = find_toplevel_char (start + 1, quote_char);
 649
 650           if (end == NULL)
 651             {
 652               if (completion_info == NULL)
 653                 error (_("Unmatched quote, %s."), start);
 654
 655               end = start + strlen (start);
 656               *inp = end;
 657               char *saved = savestring (start + 1, *inp - start - 1);
 658               return gdb::unique_xmalloc_ptr<char> (saved);
 659             }
 660
 661           if (completion_info != NULL)
 662             completion_info->quoted_arg_end = end;
 663           *inp = end + 1;
 664           char *saved = savestring (start + 1, *inp - start - 2);
 665           return gdb::unique_xmalloc_ptr<char> (saved);
 666         }
 667     }
 668
 669   const char *comma = find_toplevel_char (start, ',');
 670
 671   /* If we have "-function -myfunction", or perhaps better example,
 672      "-function -[BasicClass doIt]" (objc selector), treat
 673      "-myfunction" as the function name.  I.e., skip the first char if
 674      it is an hyphen.  Don't skip the first char always, because we
 675      may have C++ "operator<", and find_toplevel_char needs to see the
 676      'o' in that case.  */
 677   const char *hyphen
 678     = (*start == '-'
 679        ? find_toplevel_char (start + 1, '-')
 680        : find_toplevel_char (start, '-'));
 681
 682   /* Check for C++ "operator," and "operator-".  */
 683   comma = skip_op_false_positives (start, comma);
 684   hyphen = skip_op_false_positives (start, hyphen);
 685
 686   /* Pick the one that appears first.  */
 687   const char *end = first_of (hyphen, comma);
 688
 689   /* See if a linespec keyword appears first.  */
 690   const char *s = start;
 691   const char *ws = find_toplevel_char (start, ' ');
 692   while (ws != NULL && linespec_lexer_lex_keyword (ws + 1) == NULL)
 693     {
 694       s = ws + 1;
 695       ws = find_toplevel_char (s, ' ');
 696     }
 697   if (ws != NULL)
 698     end = first_of (end, ws + 1);
 699
 700   /* If we don't have any terminator, then take the whole string.  */
 701   if (end == NULL)
 702     end = start + strlen (start);
 703
 704   /* Trim whitespace at the end.  */
 705   while (end > start && end[-1] == ' ')
 706     end--;
 707
 708   *inp = end;
 709
 710   if (*inp - start > 0)
 711     return gdb::unique_xmalloc_ptr<char> (savestring (start, *inp - start));
 712
 713   return NULL;
 714 }
 715
 716 /* See description in location.h.  */
 717
 718 event_location_up
 719 string_to_explicit_location (const char **argp,
 720                              const struct language_defn *language,
 721                              explicit_completion_info *completion_info)
 722 {
 723   event_location_up location;
 724
 725   /* It is assumed that input beginning with '-' and a non-digit
 726      character is an explicit location.  "-p" is reserved, though,
 727      for probe locations.  */
 728   if (argp == NULL
 729       || *argp == NULL
 730       || *argp[0] != '-'
 731       || !isalpha ((*argp)[1])
 732       || ((*argp)[0] == '-' && (*argp)[1] == 'p'))
 733     return NULL;
 734
 735   location = new_explicit_location (NULL);
 736
 737   /* Process option/argument pairs.  dprintf_command
 738      requires that processing stop on ','.  */
 739   while ((*argp)[0] != '\0' && (*argp)[0] != ',')
 740     {
 741       int len;
 742       const char *start;
 743
 744       /* Clear these on each iteration, since they should be filled
 745          with info about the last option.  */
 746       if (completion_info != NULL)
 747         {
 748           completion_info->quoted_arg_start = NULL;
 749           completion_info->quoted_arg_end = NULL;
 750         }
 751
 752       /* If *ARGP starts with a keyword, stop processing
 753          options.  */
 754       if (linespec_lexer_lex_keyword (*argp) != NULL)
 755         break;
 756
 757       /* Mark the start of the string in case we need to rewind.  */
 758       start = *argp;
 759
 760       if (completion_info != NULL)
 761         completion_info->last_option = start;
 762
 763       /* Get the option string.  */
 764       gdb::unique_xmalloc_ptr<char> opt
 765         = explicit_location_lex_one (argp, language, NULL);
 766
 767       /* Use the length of the option to allow abbreviations.  */
 768       len = strlen (opt.get ());
 769
 770       /* Get the argument string.  */
 771       *argp = skip_spaces (*argp);
 772
 773       /* All options have a required argument.  Checking for this
 774          required argument is deferred until later.  */
 775       gdb::unique_xmalloc_ptr<char> oarg;
 776       /* True if we have an argument.  This is required because we'll
 777          move from OARG before checking whether we have an
 778          argument.  */
 779       bool have_oarg = false;
 780
 781       /* True if the option needs an argument.  */
 782       bool need_oarg = false;
 783
 784       /* Convenience to consistently set both OARG/HAVE_OARG from
 785          ARG.  */
 786       auto set_oarg = [&] (gdb::unique_xmalloc_ptr<char> arg)
 787         {
 788           if (completion_info != NULL)
 789             {
 790               /* We do this here because the set of options that take
 791                  arguments matches the set of explicit location
 792                  options.  */
 793               completion_info->saw_explicit_location_option = true;
 794             }
 795           oarg = std::move (arg);
 796           have_oarg = oarg != NULL;
 797           need_oarg = true;
 798         };
 799
 800       if (strncmp (opt.get (), "-source", len) == 0)
 801         {
 802           set_oarg (explicit_location_lex_one (argp, language,
 803                                                completion_info));
 804           EL_EXPLICIT (location)->source_filename = oarg.release ();
 805         }
 806       else if (strncmp (opt.get (), "-function", len) == 0)
 807         {
 808           set_oarg (explicit_location_lex_one_function (argp, language,
 809                                                         completion_info));
 810           EL_EXPLICIT (location)->function_name = oarg.release ();
 811         }
 812       else if (strncmp (opt.get (), "-qualified", len) == 0)
 813         {
 814           EL_EXPLICIT (location)->func_name_match_type
 815             = symbol_name_match_type::FULL;
 816         }
 817       else if (strncmp (opt.get (), "-line", len) == 0)
 818         {
 819           set_oarg (explicit_location_lex_one (argp, language, NULL));
 820           *argp = skip_spaces (*argp);
 821           if (have_oarg)
 822             {
 823               EL_EXPLICIT (location)->line_offset
 824                 = linespec_parse_line_offset (oarg.get ());
 825               continue;
 826             }
 827         }
 828       else if (strncmp (opt.get (), "-label", len) == 0)
 829         {
 830           set_oarg (explicit_location_lex_one (argp, language, completion_info));
 831           EL_EXPLICIT (location)->label_name = oarg.release ();
 832         }
 833       /* Only emit an "invalid argument" error for options
 834          that look like option strings.  */
 835       else if (opt.get ()[0] == '-' && !isdigit (opt.get ()[1]))
 836         {
 837           if (completion_info == NULL)
 838             error (_("invalid explicit location argument, \"%s\""), opt.get ());
 839         }
 840       else
 841         {
 842           /* End of the explicit location specification.
 843              Stop parsing and return whatever explicit location was
 844              parsed.  */
 845           *argp = start;
 846           break;
 847         }
 848
 849       *argp = skip_spaces (*argp);
 850
 851       /* It's a little lame to error after the fact, but in this
 852          case, it provides a much better user experience to issue
 853          the "invalid argument" error before any missing
 854          argument error.  */
 855       if (need_oarg && !have_oarg && completion_info == NULL)
 856         error (_("missing argument for \"%s\""), opt.get ());
 857     }
 858
 859   /* One special error check:  If a source filename was given
 860      without offset, function, or label, issue an error.  */
 861   if (EL_EXPLICIT (location)->source_filename != NULL
 862       && EL_EXPLICIT (location)->function_name == NULL
 863       && EL_EXPLICIT (location)->label_name == NULL
 864       && (EL_EXPLICIT (location)->line_offset.sign == LINE_OFFSET_UNKNOWN)
 865       && completion_info == NULL)
 866     {
 867       error (_("Source filename requires function, label, or "
 868                "line offset."));
 869     }
 870
 871   return location;
 872 }
 873
 874 /* See description in location.h.  */
 875
 876 event_location_up
 877 string_to_event_location_basic (const char **stringp,
 878                                 const struct language_defn *language,
 879                                 symbol_name_match_type match_type)
 880 {
 881   event_location_up location;
 882   const char *cs;
 883
 884   /* Try the input as a probe spec.  */
 885   cs = *stringp;
 886   if (cs != NULL && probe_linespec_to_static_ops (&cs) != NULL)
 887     {
 888       location = new_probe_location (*stringp);
 889       *stringp += strlen (*stringp);
 890     }
 891   else
 892     {
 893       /* Try an address location.  */
 894       if (*stringp != NULL && **stringp == '*')
 895         {
 896           const char *arg, *orig;
 897           CORE_ADDR addr;
 898
 899           orig = arg = *stringp;
 900           addr = linespec_expression_to_pc (&arg);
 901           location = new_address_location (addr, orig, arg - orig);
 902           *stringp += arg - orig;
 903         }
 904       else
 905         {
 906           /* Everything else is a linespec.  */
 907           location = new_linespec_location (stringp, match_type);
 908         }
 909     }
 910
 911   return location;
 912 }
 913
 914 /* See description in location.h.  */
 915
 916 event_location_up
 917 string_to_event_location (const char **stringp,
 918                           const struct language_defn *language,
 919                           symbol_name_match_type match_type)
 920 {
 921   const char *arg, *orig;
 922
 923   /* Try an explicit location.  */
 924   orig = arg = *stringp;
 925   event_location_up location = string_to_explicit_location (&arg, language, NULL);
 926   if (location != NULL)
 927     {
 928       /* It was a valid explicit location.  Advance STRINGP to
 929          the end of input.  */
 930       *stringp += arg - orig;
 931
 932       /* If the user really specified a location, then we're done.  */
 933       if (!event_location_empty_p (location.get ()))
 934         return location;
 935
 936       /* Otherwise, the user _only_ specified optional flags like
 937          "-qualified", otherwise string_to_explicit_location would
 938          have thrown an error.  Save the flags for "basic" linespec
 939          parsing below and discard the explicit location.  */
 940       match_type = EL_EXPLICIT (location)->func_name_match_type;
 941     }
 942
 943   /* Everything else is a "basic" linespec, address, or probe
 944      location.  */
 945   return string_to_event_location_basic (stringp, language, match_type);
 946 }
 947
 948 /* See description in location.h.  */
 949
 950 int
 951 event_location_empty_p (const struct event_location *location)
 952 {
 953   switch (EL_TYPE (location))
 954     {
 955     case LINESPEC_LOCATION:
 956       /* Linespecs are never "empty."  (NULL is a valid linespec)  */
 957       return 0;
 958
 959     case ADDRESS_LOCATION:
 960       return 0;
 961
 962     case EXPLICIT_LOCATION:
 963       return (EL_EXPLICIT (location) == NULL
 964               || (EL_EXPLICIT (location)->source_filename == NULL
 965                   && EL_EXPLICIT (location)->function_name == NULL
 966                   && EL_EXPLICIT (location)->label_name == NULL
 967                   && (EL_EXPLICIT (location)->line_offset.sign
 968                       == LINE_OFFSET_UNKNOWN)));
 969
 970     case PROBE_LOCATION:
 971       return EL_PROBE (location) == NULL;
 972
 973     default:
 974       gdb_assert_not_reached ("unknown event location type");
 975     }
 976 }
 977
 978 /* See description in location.h.  */
 979
 980 void
 981 set_event_location_string (struct event_location *location,
 982                            const char *string)
 983 {
 984   xfree (EL_STRING (location));
 985   EL_STRING (location) = string == NULL ?  NULL : xstrdup (string);
 986 }