gdb/location.c

   1 /* Data structures and API for location specs in GDB.
   2    Copyright (C) 2013-2022 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 "gdbsupport/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 static std::string
  33   explicit_to_string_internal (bool as_linespec,
  34                                const explicit_location_spec *explicit_loc);
  35
  36 /* Return a xstrdup of STR if not NULL, otherwise return NULL.  */
  37
  38 static char *
  39 maybe_xstrdup (const char *str)
  40 {
  41   return (str != nullptr ? xstrdup (str) : nullptr);
  42 }
  43
  44 probe_location_spec::probe_location_spec (std::string &&probe)
  45   : location_spec (PROBE_LOCATION_SPEC, std::move (probe))
  46 {
  47 }
  48
  49 location_spec_up
  50 probe_location_spec::clone () const
  51 {
  52   return location_spec_up (new probe_location_spec (*this));
  53 }
  54
  55 bool
  56 probe_location_spec::empty_p () const
  57 {
  58   return false;
  59 }
  60
  61 std::string probe_location_spec::compute_string () const
  62 {
  63   return std::move (m_as_string);
  64 }
  65
  66 /* A "normal" linespec.  */
  67 linespec_location_spec::linespec_location_spec
  68   (const char **linespec, symbol_name_match_type match_type_)
  69   : location_spec (LINESPEC_LOCATION_SPEC),
  70     match_type (match_type_)
  71 {
  72   if (*linespec != NULL)
  73     {
  74       const char *p;
  75       const char *orig = *linespec;
  76
  77       linespec_lex_to_end (linespec);
  78       p = remove_trailing_whitespace (orig, *linespec);
  79
  80       /* If there is no valid linespec then this will leave the
  81          spec_string as nullptr.  This behaviour is relied on in the
  82          breakpoint setting code, where spec_string being nullptr means
  83          to use the default breakpoint location.  */
  84       if ((p - orig) > 0)
  85         spec_string = savestring (orig, p - orig);
  86     }
  87 }
  88
  89 linespec_location_spec::~linespec_location_spec ()
  90 {
  91   xfree (spec_string);
  92 }
  93
  94 location_spec_up
  95 linespec_location_spec::clone () const
  96 {
  97   return location_spec_up (new linespec_location_spec (*this));
  98 }
  99
 100 bool
 101 linespec_location_spec::empty_p () const
 102 {
 103   return false;
 104 }
 105
 106 linespec_location_spec::linespec_location_spec
 107   (const linespec_location_spec &other)
 108   : location_spec (other),
 109     match_type (other.match_type),
 110     spec_string (maybe_xstrdup (other.spec_string))
 111 {
 112 }
 113
 114 std::string
 115 linespec_location_spec::compute_string () const
 116 {
 117   if (spec_string != nullptr)
 118     {
 119       if (match_type == symbol_name_match_type::FULL)
 120         return std::string ("-qualified ") + spec_string;
 121       else
 122         return spec_string;
 123     }
 124   return {};
 125 }
 126
 127 address_location_spec::address_location_spec (CORE_ADDR addr,
 128                                               const char *addr_string,
 129                                               int addr_string_len)
 130   : location_spec (ADDRESS_LOCATION_SPEC),
 131     address (addr)
 132 {
 133   if (addr_string != nullptr)
 134     m_as_string = std::string (addr_string, addr_string_len);
 135 }
 136
 137 location_spec_up
 138 address_location_spec::clone () const
 139 {
 140   return location_spec_up (new address_location_spec (*this));
 141 }
 142
 143 bool
 144 address_location_spec::empty_p () const
 145 {
 146   return false;
 147 }
 148
 149 address_location_spec::address_location_spec
 150   (const address_location_spec &other)
 151   : location_spec (other),
 152     address (other.address)
 153 {
 154 }
 155
 156 std::string
 157 address_location_spec::compute_string () const
 158 {
 159   const char *addr_string = core_addr_to_string (address);
 160   return std::string ("*") + addr_string;
 161 }
 162
 163 explicit_location_spec::explicit_location_spec ()
 164   : location_spec (EXPLICIT_LOCATION_SPEC)
 165 {
 166 }
 167
 168 explicit_location_spec::~explicit_location_spec ()
 169 {
 170   xfree (source_filename);
 171   xfree (function_name);
 172   xfree (label_name);
 173 }
 174
 175 explicit_location_spec::explicit_location_spec
 176   (const explicit_location_spec &other)
 177   : location_spec (other),
 178     source_filename (maybe_xstrdup (other.source_filename)),
 179     function_name (maybe_xstrdup (other.function_name)),
 180     func_name_match_type (other.func_name_match_type),
 181     label_name (maybe_xstrdup (other.label_name)),
 182     line_offset (other.line_offset)
 183 {
 184 }
 185
 186 location_spec_up
 187 explicit_location_spec::clone () const
 188 {
 189   return location_spec_up (new explicit_location_spec (*this));
 190 }
 191
 192 bool
 193 explicit_location_spec::empty_p () const
 194 {
 195   return (source_filename == nullptr
 196           && function_name == nullptr
 197           && label_name == nullptr
 198           && line_offset.sign == LINE_OFFSET_UNKNOWN);
 199 }
 200
 201 std::string
 202 explicit_location_spec::compute_string () const
 203 {
 204   return explicit_to_string_internal (false, this);
 205 }
 206
 207 /* See description in location.h.  */
 208
 209 location_spec_up
 210 new_linespec_location_spec (const char **linespec,
 211                             symbol_name_match_type match_type)
 212 {
 213   return location_spec_up (new linespec_location_spec (linespec,
 214                                                        match_type));
 215 }
 216
 217 /* See description in location.h.  */
 218
 219 const linespec_location_spec *
 220 as_linespec_location_spec (const location_spec *locspec)
 221 {
 222   gdb_assert (locspec->type () == LINESPEC_LOCATION_SPEC);
 223   return static_cast<const linespec_location_spec *> (locspec);
 224 }
 225
 226 /* See description in location.h.  */
 227
 228 location_spec_up
 229 new_address_location_spec (CORE_ADDR addr, const char *addr_string,
 230                            int addr_string_len)
 231 {
 232   return location_spec_up (new address_location_spec (addr, addr_string,
 233                                                       addr_string_len));
 234 }
 235
 236 /* See description in location.h.  */
 237
 238 const address_location_spec *
 239 as_address_location_spec (const location_spec *locspec)
 240 {
 241   gdb_assert (locspec->type () == ADDRESS_LOCATION_SPEC);
 242   return static_cast<const address_location_spec *> (locspec);
 243 }
 244
 245 /* See description in location.h.  */
 246
 247 location_spec_up
 248 new_probe_location_spec (std::string &&probe)
 249 {
 250   return location_spec_up (new probe_location_spec (std::move (probe)));
 251 }
 252
 253 /* See description in location.h.  */
 254
 255 const probe_location_spec *
 256 as_probe_location_spec (const location_spec *locspec)
 257 {
 258   gdb_assert (locspec->type () == PROBE_LOCATION_SPEC);
 259   return static_cast<const probe_location_spec *> (locspec);
 260 }
 261
 262 /* See description in location.h.  */
 263
 264 const explicit_location_spec *
 265 as_explicit_location_spec (const location_spec *locspec)
 266 {
 267   gdb_assert (locspec->type () == EXPLICIT_LOCATION_SPEC);
 268   return static_cast<const explicit_location_spec *> (locspec);
 269 }
 270
 271 /* See description in location.h.  */
 272
 273 explicit_location_spec *
 274 as_explicit_location_spec (location_spec *locspec)
 275 {
 276   gdb_assert (locspec->type () == EXPLICIT_LOCATION_SPEC);
 277   return static_cast<explicit_location_spec *> (locspec);
 278 }
 279
 280 /* Return a string representation of the explicit location spec in
 281    EXPLICIT_LOCSPEC.
 282
 283    AS_LINESPEC is true if this string should be a linespec.  Otherwise
 284    it will be output in explicit form.  */
 285
 286 static std::string
 287 explicit_to_string_internal (bool as_linespec,
 288                              const explicit_location_spec *explicit_loc)
 289 {
 290   bool need_space = false;
 291   char space = as_linespec ? ':' : ' ';
 292   string_file buf;
 293
 294   if (explicit_loc->source_filename != NULL)
 295     {
 296       if (!as_linespec)
 297         buf.puts ("-source ");
 298       buf.puts (explicit_loc->source_filename);
 299       need_space = true;
 300     }
 301
 302   if (explicit_loc->function_name != NULL)
 303     {
 304       if (need_space)
 305         buf.putc (space);
 306       if (explicit_loc->func_name_match_type == symbol_name_match_type::FULL)
 307         buf.puts ("-qualified ");
 308       if (!as_linespec)
 309         buf.puts ("-function ");
 310       buf.puts (explicit_loc->function_name);
 311       need_space = true;
 312     }
 313
 314   if (explicit_loc->label_name != NULL)
 315     {
 316       if (need_space)
 317         buf.putc (space);
 318       if (!as_linespec)
 319         buf.puts ("-label ");
 320       buf.puts (explicit_loc->label_name);
 321       need_space = true;
 322     }
 323
 324   if (explicit_loc->line_offset.sign != LINE_OFFSET_UNKNOWN)
 325     {
 326       if (need_space)
 327         buf.putc (space);
 328       if (!as_linespec)
 329         buf.puts ("-line ");
 330       buf.printf ("%s%d",
 331                   (explicit_loc->line_offset.sign == LINE_OFFSET_NONE ? ""
 332                    : (explicit_loc->line_offset.sign
 333                       == LINE_OFFSET_PLUS ? "+" : "-")),
 334                   explicit_loc->line_offset.offset);
 335     }
 336
 337   return buf.release ();
 338 }
 339
 340 /* See description in location.h.  */
 341
 342 std::string
 343 explicit_location_spec::to_linespec () const
 344 {
 345   return explicit_to_string_internal (true, this);
 346 }
 347
 348 /* Find an instance of the quote character C in the string S that is
 349    outside of all single- and double-quoted strings (i.e., any quoting
 350    other than C).  */
 351
 352 static const char *
 353 find_end_quote (const char *s, char end_quote_char)
 354 {
 355   /* zero if we're not in quotes;
 356      '"' if we're in a double-quoted string;
 357      '\'' if we're in a single-quoted string.  */
 358   char nested_quote_char = '\0';
 359
 360   for (const char *scan = s; *scan != '\0'; scan++)
 361     {
 362       if (nested_quote_char != '\0')
 363         {
 364           if (*scan == nested_quote_char)
 365             nested_quote_char = '\0';
 366           else if (scan[0] == '\\' && *(scan + 1) != '\0')
 367             scan++;
 368         }
 369       else if (*scan == end_quote_char && nested_quote_char == '\0')
 370         return scan;
 371       else if (*scan == '"' || *scan == '\'')
 372         nested_quote_char = *scan;
 373     }
 374
 375   return 0;
 376 }
 377
 378 /* A lexer for explicit location specs.  This function will advance
 379    INP past any strings that it lexes.  Returns a malloc'd copy of the
 380    lexed string or NULL if no lexing was done.  */
 381
 382 static gdb::unique_xmalloc_ptr<char>
 383 explicit_location_spec_lex_one (const char **inp,
 384                                 const struct language_defn *language,
 385                                 explicit_completion_info *completion_info)
 386 {
 387   const char *start = *inp;
 388
 389   if (*start == '\0')
 390     return NULL;
 391
 392   /* If quoted, skip to the ending quote.  */
 393   if (strchr (get_gdb_linespec_parser_quote_characters (), *start))
 394     {
 395       if (completion_info != NULL)
 396         completion_info->quoted_arg_start = start;
 397
 398       const char *end = find_end_quote (start + 1, *start);
 399
 400       if (end == NULL)
 401         {
 402           if (completion_info == NULL)
 403             error (_("Unmatched quote, %s."), start);
 404
 405           end = start + strlen (start);
 406           *inp = end;
 407           return gdb::unique_xmalloc_ptr<char> (savestring (start + 1,
 408                                                             *inp - start - 1));
 409         }
 410
 411       if (completion_info != NULL)
 412         completion_info->quoted_arg_end = end;
 413       *inp = end + 1;
 414       return gdb::unique_xmalloc_ptr<char> (savestring (start + 1,
 415                                                         *inp - start - 2));
 416     }
 417
 418   /* If the input starts with '-' or '+', the string ends with the next
 419      whitespace or comma.  */
 420   if (*start == '-' || *start == '+')
 421     {
 422       while (*inp[0] != '\0' && *inp[0] != ',' && !isspace (*inp[0]))
 423         ++(*inp);
 424     }
 425   else
 426     {
 427       /* Handle numbers first, stopping at the next whitespace or ','.  */
 428       while (isdigit (*inp[0]))
 429         ++(*inp);
 430       if (*inp[0] == '\0' || isspace (*inp[0]) || *inp[0] == ',')
 431         return gdb::unique_xmalloc_ptr<char> (savestring (start,
 432                                                           *inp - start));
 433
 434       /* Otherwise stop at the next occurrence of whitespace, '\0',
 435          keyword, or ','.  */
 436       *inp = start;
 437       while ((*inp)[0]
 438              && (*inp)[0] != ','
 439              && !(isspace ((*inp)[0])
 440                   || linespec_lexer_lex_keyword (&(*inp)[1])))
 441         {
 442           /* Special case: C++ operator,.  */
 443           if (language->la_language == language_cplus
 444               && startswith (*inp, CP_OPERATOR_STR))
 445             (*inp) += CP_OPERATOR_LEN;
 446           ++(*inp);
 447         }
 448     }
 449
 450   if (*inp - start > 0)
 451     return gdb::unique_xmalloc_ptr<char> (savestring (start, *inp - start));
 452
 453   return NULL;
 454 }
 455
 456 /* Return true if COMMA points past "operator".  START is the start of
 457    the line that COMMAND points to, hence when reading backwards, we
 458    must not read any character before START.  */
 459
 460 static bool
 461 is_cp_operator (const char *start, const char *comma)
 462 {
 463   if (comma != NULL
 464       && (comma - start) >= CP_OPERATOR_LEN)
 465     {
 466       const char *p = comma;
 467
 468       while (p > start && isspace (p[-1]))
 469         p--;
 470       if (p - start >= CP_OPERATOR_LEN)
 471         {
 472           p -= CP_OPERATOR_LEN;
 473           if (strncmp (p, CP_OPERATOR_STR, CP_OPERATOR_LEN) == 0
 474               && (p == start
 475                   || !(isalnum (p[-1]) || p[-1] == '_')))
 476             {
 477               return true;
 478             }
 479         }
 480     }
 481   return false;
 482 }
 483
 484 /* When scanning the input string looking for the next explicit
 485    location spec option/delimiter, we jump to the next option by looking
 486    for ",", and "-".  Such a character can also appear in C++ symbols
 487    like "operator," and "operator-".  So when we find such a
 488    character, we call this function to check if we found such a
 489    symbol, meaning we had a false positive for an option string.  In
 490    that case, we keep looking for the next delimiter, until we find
 491    one that is not a false positive, or we reach end of string.  FOUND
 492    is the character that scanning found (either '-' or ','), and START
 493    is the start of the line that FOUND points to, hence when reading
 494    backwards, we must not read any character before START.  Returns a
 495    pointer to the next non-false-positive delimiter character, or NULL
 496    if none was found.  */
 497
 498 static const char *
 499 skip_op_false_positives (const char *start, const char *found)
 500 {
 501   while (found != NULL && is_cp_operator (start, found))
 502     {
 503       if (found[0] == '-' && found[1] == '-')
 504         start = found + 2;
 505       else
 506         start = found + 1;
 507       found = find_toplevel_char (start, *found);
 508     }
 509
 510   return found;
 511 }
 512
 513 /* Assuming both FIRST and NEW_TOK point into the same string, return
 514    the pointer that is closer to the start of the string.  If FIRST is
 515    NULL, returns NEW_TOK.  If NEW_TOK is NULL, returns FIRST.  */
 516
 517 static const char *
 518 first_of (const char *first, const char *new_tok)
 519 {
 520   if (first == NULL)
 521     return new_tok;
 522   else if (new_tok != NULL && new_tok < first)
 523     return new_tok;
 524   else
 525     return first;
 526 }
 527
 528 /* A lexer for functions in explicit location specs.  This function will
 529    advance INP past a function until the next option, or until end of
 530    string.  Returns a malloc'd copy of the lexed string or NULL if no
 531    lexing was done.  */
 532
 533 static gdb::unique_xmalloc_ptr<char>
 534 explicit_location_spec_lex_one_function
 535   (const char **inp,
 536    const struct language_defn *language,
 537    explicit_completion_info *completion_info)
 538 {
 539   const char *start = *inp;
 540
 541   if (*start == '\0')
 542     return NULL;
 543
 544   /* If quoted, skip to the ending quote.  */
 545   if (strchr (get_gdb_linespec_parser_quote_characters (), *start))
 546     {
 547       char quote_char = *start;
 548
 549       /* If the input is not an Ada operator, skip to the matching
 550          closing quote and return the string.  */
 551       if (!(language->la_language == language_ada
 552             && quote_char == '\"' && is_ada_operator (start)))
 553         {
 554           if (completion_info != NULL)
 555             completion_info->quoted_arg_start = start;
 556
 557           const char *end = find_toplevel_char (start + 1, quote_char);
 558
 559           if (end == NULL)
 560             {
 561               if (completion_info == NULL)
 562                 error (_("Unmatched quote, %s."), start);
 563
 564               end = start + strlen (start);
 565               *inp = end;
 566               char *saved = savestring (start + 1, *inp - start - 1);
 567               return gdb::unique_xmalloc_ptr<char> (saved);
 568             }
 569
 570           if (completion_info != NULL)
 571             completion_info->quoted_arg_end = end;
 572           *inp = end + 1;
 573           char *saved = savestring (start + 1, *inp - start - 2);
 574           return gdb::unique_xmalloc_ptr<char> (saved);
 575         }
 576     }
 577
 578   const char *comma = find_toplevel_char (start, ',');
 579
 580   /* If we have "-function -myfunction", or perhaps better example,
 581      "-function -[BasicClass doIt]" (objc selector), treat
 582      "-myfunction" as the function name.  I.e., skip the first char if
 583      it is an hyphen.  Don't skip the first char always, because we
 584      may have C++ "operator<", and find_toplevel_char needs to see the
 585      'o' in that case.  */
 586   const char *hyphen
 587     = (*start == '-'
 588        ? find_toplevel_char (start + 1, '-')
 589        : find_toplevel_char (start, '-'));
 590
 591   /* Check for C++ "operator," and "operator-".  */
 592   comma = skip_op_false_positives (start, comma);
 593   hyphen = skip_op_false_positives (start, hyphen);
 594
 595   /* Pick the one that appears first.  */
 596   const char *end = first_of (hyphen, comma);
 597
 598   /* See if a linespec keyword appears first.  */
 599   const char *s = start;
 600   const char *ws = find_toplevel_char (start, ' ');
 601   while (ws != NULL && linespec_lexer_lex_keyword (ws + 1) == NULL)
 602     {
 603       s = ws + 1;
 604       ws = find_toplevel_char (s, ' ');
 605     }
 606   if (ws != NULL)
 607     end = first_of (end, ws + 1);
 608
 609   /* If we don't have any terminator, then take the whole string.  */
 610   if (end == NULL)
 611     end = start + strlen (start);
 612
 613   /* Trim whitespace at the end.  */
 614   while (end > start && end[-1] == ' ')
 615     end--;
 616
 617   *inp = end;
 618
 619   if (*inp - start > 0)
 620     return gdb::unique_xmalloc_ptr<char> (savestring (start, *inp - start));
 621
 622   return NULL;
 623 }
 624
 625 /* See description in location.h.  */
 626
 627 location_spec_up
 628 string_to_explicit_location_spec (const char **argp,
 629                                   const struct language_defn *language,
 630                                   explicit_completion_info *completion_info)
 631 {
 632   /* It is assumed that input beginning with '-' and a non-digit
 633      character is an explicit location.  "-p" is reserved, though,
 634      for probe locations.  */
 635   if (argp == NULL
 636       || *argp == NULL
 637       || *argp[0] != '-'
 638       || !isalpha ((*argp)[1])
 639       || ((*argp)[0] == '-' && (*argp)[1] == 'p'))
 640     return NULL;
 641
 642   std::unique_ptr<explicit_location_spec> locspec
 643     (new explicit_location_spec ());
 644
 645   /* Process option/argument pairs.  dprintf_command
 646      requires that processing stop on ','.  */
 647   while ((*argp)[0] != '\0' && (*argp)[0] != ',')
 648     {
 649       int len;
 650       const char *start;
 651
 652       /* Clear these on each iteration, since they should be filled
 653          with info about the last option.  */
 654       if (completion_info != NULL)
 655         {
 656           completion_info->quoted_arg_start = NULL;
 657           completion_info->quoted_arg_end = NULL;
 658         }
 659
 660       /* If *ARGP starts with a keyword, stop processing
 661          options.  */
 662       if (linespec_lexer_lex_keyword (*argp) != NULL)
 663         break;
 664
 665       /* Mark the start of the string in case we need to rewind.  */
 666       start = *argp;
 667
 668       if (completion_info != NULL)
 669         completion_info->last_option = start;
 670
 671       /* Get the option string.  */
 672       gdb::unique_xmalloc_ptr<char> opt
 673         = explicit_location_spec_lex_one (argp, language, NULL);
 674
 675       /* Use the length of the option to allow abbreviations.  */
 676       len = strlen (opt.get ());
 677
 678       /* Get the argument string.  */
 679       *argp = skip_spaces (*argp);
 680
 681       /* All options have a required argument.  Checking for this
 682          required argument is deferred until later.  */
 683       gdb::unique_xmalloc_ptr<char> oarg;
 684       /* True if we have an argument.  This is required because we'll
 685          move from OARG before checking whether we have an
 686          argument.  */
 687       bool have_oarg = false;
 688
 689       /* True if the option needs an argument.  */
 690       bool need_oarg = false;
 691
 692       /* Convenience to consistently set both OARG/HAVE_OARG from
 693          ARG.  */
 694       auto set_oarg = [&] (gdb::unique_xmalloc_ptr<char> arg)
 695         {
 696           if (completion_info != NULL)
 697             {
 698               /* We do this here because the set of options that take
 699                  arguments matches the set of explicit location
 700                  options.  */
 701               completion_info->saw_explicit_location_spec_option = true;
 702             }
 703           oarg = std::move (arg);
 704           have_oarg = oarg != NULL;
 705           need_oarg = true;
 706         };
 707
 708       if (strncmp (opt.get (), "-source", len) == 0)
 709         {
 710           set_oarg (explicit_location_spec_lex_one (argp, language,
 711                                                     completion_info));
 712           locspec->source_filename = oarg.release ();
 713         }
 714       else if (strncmp (opt.get (), "-function", len) == 0)
 715         {
 716           set_oarg (explicit_location_spec_lex_one_function (argp, language,
 717                                                              completion_info));
 718           locspec->function_name = oarg.release ();
 719         }
 720       else if (strncmp (opt.get (), "-qualified", len) == 0)
 721         {
 722           locspec->func_name_match_type = symbol_name_match_type::FULL;
 723         }
 724       else if (strncmp (opt.get (), "-line", len) == 0)
 725         {
 726           set_oarg (explicit_location_spec_lex_one (argp, language, NULL));
 727           *argp = skip_spaces (*argp);
 728           if (have_oarg)
 729             {
 730               locspec->line_offset = linespec_parse_line_offset (oarg.get ());
 731               continue;
 732             }
 733         }
 734       else if (strncmp (opt.get (), "-label", len) == 0)
 735         {
 736           set_oarg (explicit_location_spec_lex_one (argp, language,
 737                                                     completion_info));
 738           locspec->label_name = oarg.release ();
 739         }
 740       /* Only emit an "invalid argument" error for options
 741          that look like option strings.  */
 742       else if (opt.get ()[0] == '-' && !isdigit (opt.get ()[1]))
 743         {
 744           if (completion_info == NULL)
 745             error (_("invalid explicit location argument, \"%s\""), opt.get ());
 746         }
 747       else
 748         {
 749           /* End of the explicit location specification.
 750              Stop parsing and return whatever explicit location was
 751              parsed.  */
 752           *argp = start;
 753           break;
 754         }
 755
 756       *argp = skip_spaces (*argp);
 757
 758       /* It's a little lame to error after the fact, but in this
 759          case, it provides a much better user experience to issue
 760          the "invalid argument" error before any missing
 761          argument error.  */
 762       if (need_oarg && !have_oarg && completion_info == NULL)
 763         error (_("missing argument for \"%s\""), opt.get ());
 764     }
 765
 766   /* One special error check:  If a source filename was given
 767      without offset, function, or label, issue an error.  */
 768   if (locspec->source_filename != NULL
 769       && locspec->function_name == NULL
 770       && locspec->label_name == NULL
 771       && (locspec->line_offset.sign == LINE_OFFSET_UNKNOWN)
 772       && completion_info == NULL)
 773     {
 774       error (_("Source filename requires function, label, or "
 775                "line offset."));
 776     }
 777
 778   return location_spec_up (locspec.release ());
 779 }
 780
 781 /* See description in location.h.  */
 782
 783 location_spec_up
 784 string_to_location_spec_basic (const char **stringp,
 785                                const struct language_defn *language,
 786                                symbol_name_match_type match_type)
 787 {
 788   location_spec_up locspec;
 789   const char *cs;
 790
 791   /* Try the input as a probe spec.  */
 792   cs = *stringp;
 793   if (cs != NULL && probe_linespec_to_static_ops (&cs) != NULL)
 794     {
 795       locspec = new_probe_location_spec (*stringp);
 796       *stringp += strlen (*stringp);
 797     }
 798   else
 799     {
 800       /* Try an address location spec.  */
 801       if (*stringp != NULL && **stringp == '*')
 802         {
 803           const char *arg, *orig;
 804           CORE_ADDR addr;
 805
 806           orig = arg = *stringp;
 807           addr = linespec_expression_to_pc (&arg);
 808           locspec = new_address_location_spec (addr, orig, arg - orig);
 809           *stringp += arg - orig;
 810         }
 811       else
 812         {
 813           /* Everything else is a linespec.  */
 814           locspec = new_linespec_location_spec (stringp, match_type);
 815         }
 816     }
 817
 818   return locspec;
 819 }
 820
 821 /* See description in location.h.  */
 822
 823 location_spec_up
 824 string_to_location_spec (const char **stringp,
 825                          const struct language_defn *language,
 826                          symbol_name_match_type match_type)
 827 {
 828   const char *arg, *orig;
 829
 830   /* Try an explicit location spec.  */
 831   orig = arg = *stringp;
 832   location_spec_up locspec
 833     = string_to_explicit_location_spec (&arg, language, NULL);
 834   if (locspec != nullptr)
 835     {
 836       /* It was a valid explicit location.  Advance STRINGP to
 837          the end of input.  */
 838       *stringp += arg - orig;
 839
 840       /* If the user really specified a location spec, then we're
 841          done.  */
 842       if (!locspec->empty_p ())
 843         return locspec;
 844
 845       /* Otherwise, the user _only_ specified optional flags like
 846          "-qualified", otherwise string_to_explicit_location_spec
 847          would have thrown an error.  Save the flags for "basic"
 848          linespec parsing below and discard the explicit location
 849          spec.  */
 850       explicit_location_spec *xloc
 851         = dynamic_cast<explicit_location_spec *> (locspec.get ());
 852       gdb_assert (xloc != nullptr);
 853       match_type = xloc->func_name_match_type;
 854     }
 855
 856   /* Everything else is a "basic" linespec, address, or probe location
 857      spec.  */
 858   return string_to_location_spec_basic (stringp, language, match_type);
 859 }