gdb/location.c

   1 /* Data structures and API for event locations in GDB.
   2    Copyright (C) 2013-2017 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
  28 #include <ctype.h>
  29 #include <string.h>
  30
  31 /* An event location used to set a stop event in the inferior.
  32    This structure is an amalgam of the various ways
  33    to specify where a stop event should be set.  */
  34
  35 struct event_location
  36 {
  37   /* The type of this breakpoint specification.  */
  38   enum event_location_type type;
  39 #define EL_TYPE(P) (P)->type
  40
  41   union
  42   {
  43     /* A generic "this is a string specification" for a location.
  44        This representation is used by both "normal" linespecs and
  45        probes.  */
  46     char *addr_string;
  47 #define EL_LINESPEC(P) ((P)->u.addr_string)
  48 #define EL_PROBE(P) ((P)->u.addr_string)
  49
  50     /* An address in the inferior.  */
  51     CORE_ADDR address;
  52 #define EL_ADDRESS(P) (P)->u.address
  53
  54     /* An explicit location.  */
  55     struct explicit_location explicit_loc;
  56 #define EL_EXPLICIT(P) (&((P)->u.explicit_loc))
  57   } u;
  58
  59   /* Cached string representation of this location.  This is used, e.g., to
  60      save stop event locations to file.  Malloc'd.  */
  61   char *as_string;
  62 #define EL_STRING(P) ((P)->as_string)
  63 };
  64
  65 /* See description in location.h.  */
  66
  67 enum event_location_type
  68 event_location_type (const struct event_location *location)
  69 {
  70   return EL_TYPE (location);
  71 }
  72
  73 /* See description in location.h.  */
  74
  75 void
  76 initialize_explicit_location (struct explicit_location *explicit_loc)
  77 {
  78   memset (explicit_loc, 0, sizeof (struct explicit_location));
  79   explicit_loc->line_offset.sign = LINE_OFFSET_UNKNOWN;
  80 }
  81
  82 /* See description in location.h.  */
  83
  84 event_location_up
  85 new_linespec_location (char **linespec)
  86 {
  87   struct event_location *location;
  88
  89   location = XCNEW (struct event_location);
  90   EL_TYPE (location) = LINESPEC_LOCATION;
  91   if (*linespec != NULL)
  92     {
  93       char *p;
  94       char *orig = *linespec;
  95
  96       linespec_lex_to_end (linespec);
  97       p = remove_trailing_whitespace (orig, *linespec);
  98       if ((p - orig) > 0)
  99         EL_LINESPEC (location) = savestring (orig, p - orig);
 100     }
 101   return event_location_up (location);
 102 }
 103
 104 /* See description in location.h.  */
 105
 106 const char *
 107 get_linespec_location (const struct event_location *location)
 108 {
 109   gdb_assert (EL_TYPE (location) == LINESPEC_LOCATION);
 110   return EL_LINESPEC (location);
 111 }
 112
 113 /* See description in location.h.  */
 114
 115 event_location_up
 116 new_address_location (CORE_ADDR addr, const char *addr_string,
 117                       int addr_string_len)
 118 {
 119   struct event_location *location;
 120
 121   location = XCNEW (struct event_location);
 122   EL_TYPE (location) = ADDRESS_LOCATION;
 123   EL_ADDRESS (location) = addr;
 124   if (addr_string != NULL)
 125     EL_STRING (location) = xstrndup (addr_string, addr_string_len);
 126   return event_location_up (location);
 127 }
 128
 129 /* See description in location.h.  */
 130
 131 CORE_ADDR
 132 get_address_location (const struct event_location *location)
 133 {
 134   gdb_assert (EL_TYPE (location) == ADDRESS_LOCATION);
 135   return EL_ADDRESS (location);
 136 }
 137
 138 /* See description in location.h.  */
 139
 140 const char *
 141 get_address_string_location (const struct event_location *location)
 142 {
 143   gdb_assert (EL_TYPE (location) == ADDRESS_LOCATION);
 144   return EL_STRING (location);
 145 }
 146
 147 /* See description in location.h.  */
 148
 149 event_location_up
 150 new_probe_location (const char *probe)
 151 {
 152   struct event_location *location;
 153
 154   location = XCNEW (struct event_location);
 155   EL_TYPE (location) = PROBE_LOCATION;
 156   if (probe != NULL)
 157     EL_PROBE (location) = xstrdup (probe);
 158   return event_location_up (location);
 159 }
 160
 161 /* See description in location.h.  */
 162
 163 const char *
 164 get_probe_location (const struct event_location *location)
 165 {
 166   gdb_assert (EL_TYPE (location) == PROBE_LOCATION);
 167   return EL_PROBE (location);
 168 }
 169
 170 /* See description in location.h.  */
 171
 172 event_location_up
 173 new_explicit_location (const struct explicit_location *explicit_loc)
 174 {
 175   struct event_location tmp;
 176
 177   memset (&tmp, 0, sizeof (struct event_location));
 178   EL_TYPE (&tmp) = EXPLICIT_LOCATION;
 179   initialize_explicit_location (EL_EXPLICIT (&tmp));
 180   if (explicit_loc != NULL)
 181     {
 182       if (explicit_loc->source_filename != NULL)
 183         {
 184           EL_EXPLICIT (&tmp)->source_filename
 185             = explicit_loc->source_filename;
 186         }
 187
 188       if (explicit_loc->function_name != NULL)
 189         EL_EXPLICIT (&tmp)->function_name
 190           = explicit_loc->function_name;
 191
 192       if (explicit_loc->label_name != NULL)
 193         EL_EXPLICIT (&tmp)->label_name = explicit_loc->label_name;
 194
 195       if (explicit_loc->line_offset.sign != LINE_OFFSET_UNKNOWN)
 196         EL_EXPLICIT (&tmp)->line_offset = explicit_loc->line_offset;
 197     }
 198
 199   return copy_event_location (&tmp);
 200 }
 201
 202 /* See description in location.h.  */
 203
 204 struct explicit_location *
 205 get_explicit_location (struct event_location *location)
 206 {
 207   gdb_assert (EL_TYPE (location) == EXPLICIT_LOCATION);
 208   return EL_EXPLICIT (location);
 209 }
 210
 211 /* See description in location.h.  */
 212
 213 const struct explicit_location *
 214 get_explicit_location_const (const struct event_location *location)
 215 {
 216   gdb_assert (EL_TYPE (location) == EXPLICIT_LOCATION);
 217   return EL_EXPLICIT (location);
 218 }
 219
 220 /* This convenience function returns a malloc'd string which
 221    represents the location in EXPLICIT_LOC.
 222
 223    AS_LINESPEC is non-zero if this string should be a linespec.
 224    Otherwise it will be output in explicit form.  */
 225
 226 static char *
 227 explicit_to_string_internal (int as_linespec,
 228                              const struct explicit_location *explicit_loc)
 229 {
 230   int need_space = 0;
 231   char space = as_linespec ? ':' : ' ';
 232   string_file buf;
 233
 234   if (explicit_loc->source_filename != NULL)
 235     {
 236       if (!as_linespec)
 237         buf.puts ("-source ");
 238       buf.puts (explicit_loc->source_filename);
 239       need_space = 1;
 240     }
 241
 242   if (explicit_loc->function_name != NULL)
 243     {
 244       if (need_space)
 245         buf.putc (space);
 246       if (!as_linespec)
 247         buf.puts ("-function ");
 248       buf.puts (explicit_loc->function_name);
 249       need_space = 1;
 250     }
 251
 252   if (explicit_loc->label_name != NULL)
 253     {
 254       if (need_space)
 255         buf.putc (space);
 256       if (!as_linespec)
 257         buf.puts ("-label ");
 258       buf.puts (explicit_loc->label_name);
 259       need_space = 1;
 260     }
 261
 262   if (explicit_loc->line_offset.sign != LINE_OFFSET_UNKNOWN)
 263     {
 264       if (need_space)
 265         buf.putc (space);
 266       if (!as_linespec)
 267         buf.puts ("-line ");
 268       buf.printf ("%s%d",
 269                   (explicit_loc->line_offset.sign == LINE_OFFSET_NONE ? ""
 270                    : (explicit_loc->line_offset.sign
 271                       == LINE_OFFSET_PLUS ? "+" : "-")),
 272                   explicit_loc->line_offset.offset);
 273     }
 274
 275   return xstrdup (buf.c_str ());
 276 }
 277
 278 /* See description in location.h.  */
 279
 280 char *
 281 explicit_location_to_string (const struct explicit_location *explicit_loc)
 282 {
 283   return explicit_to_string_internal (0, explicit_loc);
 284 }
 285
 286 /* See description in location.h.  */
 287
 288 char *
 289 explicit_location_to_linespec (const struct explicit_location *explicit_loc)
 290 {
 291   return explicit_to_string_internal (1, explicit_loc);
 292 }
 293
 294 /* See description in location.h.  */
 295
 296 event_location_up
 297 copy_event_location (const struct event_location *src)
 298 {
 299   struct event_location *dst;
 300
 301   dst = XCNEW (struct event_location);
 302   EL_TYPE (dst) = EL_TYPE (src);
 303   if (EL_STRING (src) != NULL)
 304     EL_STRING (dst) = xstrdup (EL_STRING (src));
 305
 306   switch (EL_TYPE (src))
 307     {
 308     case LINESPEC_LOCATION:
 309       if (EL_LINESPEC (src) != NULL)
 310         EL_LINESPEC (dst) = xstrdup (EL_LINESPEC (src));
 311       break;
 312
 313     case ADDRESS_LOCATION:
 314       EL_ADDRESS (dst) = EL_ADDRESS (src);
 315       break;
 316
 317     case EXPLICIT_LOCATION:
 318       if (EL_EXPLICIT (src)->source_filename != NULL)
 319         EL_EXPLICIT (dst)->source_filename
 320           = xstrdup (EL_EXPLICIT (src)->source_filename);
 321
 322       if (EL_EXPLICIT (src)->function_name != NULL)
 323         EL_EXPLICIT (dst)->function_name
 324           = xstrdup (EL_EXPLICIT (src)->function_name);
 325
 326       if (EL_EXPLICIT (src)->label_name != NULL)
 327         EL_EXPLICIT (dst)->label_name = xstrdup (EL_EXPLICIT (src)->label_name);
 328
 329       EL_EXPLICIT (dst)->line_offset = EL_EXPLICIT (src)->line_offset;
 330       break;
 331
 332
 333     case PROBE_LOCATION:
 334       if (EL_PROBE (src) != NULL)
 335         EL_PROBE (dst) = xstrdup (EL_PROBE (src));
 336       break;
 337
 338     default:
 339       gdb_assert_not_reached ("unknown event location type");
 340     }
 341
 342   return event_location_up (dst);
 343 }
 344
 345 /* See description in location.h.  */
 346
 347 void
 348 delete_event_location (struct event_location *location)
 349 {
 350   if (location != NULL)
 351     {
 352       xfree (EL_STRING (location));
 353
 354       switch (EL_TYPE (location))
 355         {
 356         case LINESPEC_LOCATION:
 357           xfree (EL_LINESPEC (location));
 358           break;
 359
 360         case ADDRESS_LOCATION:
 361           /* Nothing to do.  */
 362           break;
 363
 364         case EXPLICIT_LOCATION:
 365           xfree (EL_EXPLICIT (location)->source_filename);
 366           xfree (EL_EXPLICIT (location)->function_name);
 367           xfree (EL_EXPLICIT (location)->label_name);
 368           break;
 369
 370         case PROBE_LOCATION:
 371           xfree (EL_PROBE (location));
 372           break;
 373
 374         default:
 375           gdb_assert_not_reached ("unknown event location type");
 376         }
 377
 378       xfree (location);
 379     }
 380 }
 381
 382 /* See description in location.h.  */
 383
 384 const char *
 385 event_location_to_string (struct event_location *location)
 386 {
 387   if (EL_STRING (location) == NULL)
 388     {
 389       switch (EL_TYPE (location))
 390         {
 391         case LINESPEC_LOCATION:
 392           if (EL_LINESPEC (location) != NULL)
 393             EL_STRING (location) = xstrdup (EL_LINESPEC (location));
 394           break;
 395
 396         case ADDRESS_LOCATION:
 397           EL_STRING (location)
 398             = xstrprintf ("*%s",
 399                           core_addr_to_string (EL_ADDRESS (location)));
 400           break;
 401
 402         case EXPLICIT_LOCATION:
 403           EL_STRING (location)
 404             = explicit_location_to_string (EL_EXPLICIT (location));
 405           break;
 406
 407         case PROBE_LOCATION:
 408           EL_STRING (location) = xstrdup (EL_PROBE (location));
 409           break;
 410
 411         default:
 412           gdb_assert_not_reached ("unknown event location type");
 413         }
 414     }
 415
 416   return EL_STRING (location);
 417 }
 418
 419 /* A lexer for explicit locations.  This function will advance INP
 420    past any strings that it lexes.  Returns a malloc'd copy of the
 421    lexed string or NULL if no lexing was done.  */
 422
 423 static gdb::unique_xmalloc_ptr<char>
 424 explicit_location_lex_one (const char **inp,
 425                            const struct language_defn *language)
 426 {
 427   const char *start = *inp;
 428
 429   if (*start == '\0')
 430     return NULL;
 431
 432   /* If quoted, skip to the ending quote.  */
 433   if (strchr (get_gdb_linespec_parser_quote_characters (), *start))
 434     {
 435       char quote_char = *start;
 436
 437       /* If the input is not an Ada operator, skip to the matching
 438          closing quote and return the string.  */
 439       if (!(language->la_language == language_ada
 440             && quote_char == '\"' && is_ada_operator (start)))
 441         {
 442           const char *end = find_toplevel_char (start + 1, quote_char);
 443
 444           if (end == NULL)
 445             error (_("Unmatched quote, %s."), start);
 446           *inp = end + 1;
 447           return gdb::unique_xmalloc_ptr<char> (savestring (start + 1,
 448                                                             *inp - start - 2));
 449         }
 450     }
 451
 452   /* If the input starts with '-' or '+', the string ends with the next
 453      whitespace or comma.  */
 454   if (*start == '-' || *start == '+')
 455     {
 456       while (*inp[0] != '\0' && *inp[0] != ',' && !isspace (*inp[0]))
 457         ++(*inp);
 458     }
 459   else
 460     {
 461       /* Handle numbers first, stopping at the next whitespace or ','.  */
 462       while (isdigit (*inp[0]))
 463         ++(*inp);
 464       if (*inp[0] == '\0' || isspace (*inp[0]) || *inp[0] == ',')
 465         return gdb::unique_xmalloc_ptr<char> (savestring (start,
 466                                                           *inp - start));
 467
 468       /* Otherwise stop at the next occurrence of whitespace, '\0',
 469          keyword, or ','.  */
 470       *inp = start;
 471       while ((*inp)[0]
 472              && (*inp)[0] != ','
 473              && !(isspace ((*inp)[0])
 474                   || linespec_lexer_lex_keyword (&(*inp)[1])))
 475         {
 476           /* Special case: C++ operator,.  */
 477           if (language->la_language == language_cplus
 478               && strncmp (*inp, "operator", 8) == 0)
 479             (*inp) += 8;
 480           ++(*inp);
 481         }
 482     }
 483
 484   if (*inp - start > 0)
 485     return gdb::unique_xmalloc_ptr<char> (savestring (start, *inp - start));
 486
 487   return NULL;
 488 }
 489
 490 /* See description in location.h.  */
 491
 492 event_location_up
 493 string_to_explicit_location (const char **argp,
 494                              const struct language_defn *language,
 495                              int dont_throw)
 496 {
 497   event_location_up location;
 498
 499   /* It is assumed that input beginning with '-' and a non-digit
 500      character is an explicit location.  "-p" is reserved, though,
 501      for probe locations.  */
 502   if (argp == NULL
 503       || *argp == NULL
 504       || *argp[0] != '-'
 505       || !isalpha ((*argp)[1])
 506       || ((*argp)[0] == '-' && (*argp)[1] == 'p'))
 507     return NULL;
 508
 509   location = new_explicit_location (NULL);
 510
 511   /* Process option/argument pairs.  dprintf_command
 512      requires that processing stop on ','.  */
 513   while ((*argp)[0] != '\0' && (*argp)[0] != ',')
 514     {
 515       int len;
 516       const char *start;
 517
 518       /* If *ARGP starts with a keyword, stop processing
 519          options.  */
 520       if (linespec_lexer_lex_keyword (*argp) != NULL)
 521         break;
 522
 523       /* Mark the start of the string in case we need to rewind.  */
 524       start = *argp;
 525
 526       /* Get the option string.  */
 527       gdb::unique_xmalloc_ptr<char> opt
 528         = explicit_location_lex_one (argp, language);
 529
 530       *argp = skip_spaces_const (*argp);
 531
 532       /* Get the argument string.  */
 533       gdb::unique_xmalloc_ptr<char> oarg
 534         = explicit_location_lex_one (argp, language);
 535       bool have_oarg = oarg != NULL;
 536       *argp = skip_spaces_const (*argp);
 537
 538       /* Use the length of the option to allow abbreviations.  */
 539       len = strlen (opt.get ());
 540
 541       /* All options have a required argument.  Checking for this required
 542          argument is deferred until later.  */
 543       if (strncmp (opt.get (), "-source", len) == 0)
 544         EL_EXPLICIT (location)->source_filename = oarg.release ();
 545       else if (strncmp (opt.get (), "-function", len) == 0)
 546         EL_EXPLICIT (location)->function_name = oarg.release ();
 547       else if (strncmp (opt.get (), "-line", len) == 0)
 548         {
 549           if (have_oarg)
 550             EL_EXPLICIT (location)->line_offset
 551               = linespec_parse_line_offset (oarg.get ());
 552         }
 553       else if (strncmp (opt.get (), "-label", len) == 0)
 554         EL_EXPLICIT (location)->label_name = oarg.release ();
 555       /* Only emit an "invalid argument" error for options
 556          that look like option strings.  */
 557       else if (opt.get ()[0] == '-' && !isdigit (opt.get ()[1]))
 558         {
 559           if (!dont_throw)
 560             error (_("invalid explicit location argument, \"%s\""), opt.get ());
 561         }
 562       else
 563         {
 564           /* End of the explicit location specification.
 565              Stop parsing and return whatever explicit location was
 566              parsed.  */
 567           *argp = start;
 568           return location;
 569         }
 570
 571       /* It's a little lame to error after the fact, but in this
 572          case, it provides a much better user experience to issue
 573          the "invalid argument" error before any missing
 574          argument error.  */
 575       if (!have_oarg && !dont_throw)
 576         error (_("missing argument for \"%s\""), opt.get ());
 577     }
 578
 579   /* One special error check:  If a source filename was given
 580      without offset, function, or label, issue an error.  */
 581   if (EL_EXPLICIT (location)->source_filename != NULL
 582       && EL_EXPLICIT (location)->function_name == NULL
 583       && EL_EXPLICIT (location)->label_name == NULL
 584       && (EL_EXPLICIT (location)->line_offset.sign == LINE_OFFSET_UNKNOWN)
 585       && !dont_throw)
 586     {
 587       error (_("Source filename requires function, label, or "
 588                "line offset."));
 589     }
 590
 591   return location;
 592 }
 593
 594 /* See description in location.h.  */
 595
 596 event_location_up
 597 string_to_event_location_basic (char **stringp,
 598                                 const struct language_defn *language)
 599 {
 600   event_location_up location;
 601   const char *cs;
 602
 603   /* Try the input as a probe spec.  */
 604   cs = *stringp;
 605   if (cs != NULL && probe_linespec_to_ops (&cs) != NULL)
 606     {
 607       location = new_probe_location (*stringp);
 608       *stringp += strlen (*stringp);
 609     }
 610   else
 611     {
 612       /* Try an address location.  */
 613       if (*stringp != NULL && **stringp == '*')
 614         {
 615           const char *arg, *orig;
 616           CORE_ADDR addr;
 617
 618           orig = arg = *stringp;
 619           addr = linespec_expression_to_pc (&arg);
 620           location = new_address_location (addr, orig, arg - orig);
 621           *stringp += arg - orig;
 622         }
 623       else
 624         {
 625           /* Everything else is a linespec.  */
 626           location = new_linespec_location (stringp);
 627         }
 628     }
 629
 630   return location;
 631 }
 632
 633 /* See description in location.h.  */
 634
 635 event_location_up
 636 string_to_event_location (char **stringp,
 637                           const struct language_defn *language)
 638 {
 639   const char *arg, *orig;
 640
 641   /* Try an explicit location.  */
 642   orig = arg = *stringp;
 643   event_location_up location = string_to_explicit_location (&arg, language, 0);
 644   if (location != NULL)
 645     {
 646       /* It was a valid explicit location.  Advance STRINGP to
 647          the end of input.  */
 648       *stringp += arg - orig;
 649     }
 650   else
 651     {
 652       /* Everything else is a "basic" linespec, address, or probe
 653          location.  */
 654       location = string_to_event_location_basic (stringp, language);
 655     }
 656
 657   return location;
 658 }
 659
 660 /* See description in location.h.  */
 661
 662 int
 663 event_location_empty_p (const struct event_location *location)
 664 {
 665   switch (EL_TYPE (location))
 666     {
 667     case LINESPEC_LOCATION:
 668       /* Linespecs are never "empty."  (NULL is a valid linespec)  */
 669       return 0;
 670
 671     case ADDRESS_LOCATION:
 672       return 0;
 673
 674     case EXPLICIT_LOCATION:
 675       return (EL_EXPLICIT (location) == NULL
 676               || (EL_EXPLICIT (location)->source_filename == NULL
 677                   && EL_EXPLICIT (location)->function_name == NULL
 678                   && EL_EXPLICIT (location)->label_name == NULL
 679                   && (EL_EXPLICIT (location)->line_offset.sign
 680                       == LINE_OFFSET_UNKNOWN)));
 681
 682     case PROBE_LOCATION:
 683       return EL_PROBE (location) == NULL;
 684
 685     default:
 686       gdb_assert_not_reached ("unknown event location type");
 687     }
 688 }
 689
 690 /* See description in location.h.  */
 691
 692 void
 693 set_event_location_string (struct event_location *location,
 694                            const char *string)
 695 {
 696   xfree (EL_STRING (location));
 697   EL_STRING (location) = string == NULL ?  NULL : xstrdup (string);
 698 }