gdb/c-lang.c

   1 /* C language support routines for GDB, the GNU debugger.
   2
   3    Copyright (C) 1992-2019 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 "symtab.h"
  22 #include "gdbtypes.h"
  23 #include "expression.h"
  24 #include "parser-defs.h"
  25 #include "language.h"
  26 #include "varobj.h"
  27 #include "c-lang.h"
  28 #include "c-support.h"
  29 #include "valprint.h"
  30 #include "macroscope.h"
  31 #include "charset.h"
  32 #include "demangle.h"
  33 #include "cp-abi.h"
  34 #include "cp-support.h"
  35 #include "gdb_obstack.h"
  36 #include <ctype.h>
  37 #include "gdbcore.h"
  38
  39 /* Given a C string type, STR_TYPE, return the corresponding target
  40    character set name.  */
  41
  42 static const char *
  43 charset_for_string_type (c_string_type str_type, struct gdbarch *gdbarch)
  44 {
  45   switch (str_type & ~C_CHAR)
  46     {
  47     case C_STRING:
  48       return target_charset (gdbarch);
  49     case C_WIDE_STRING:
  50       return target_wide_charset (gdbarch);
  51     case C_STRING_16:
  52       /* FIXME: UTF-16 is not always correct.  */
  53       if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
  54         return "UTF-16BE";
  55       else
  56         return "UTF-16LE";
  57     case C_STRING_32:
  58       /* FIXME: UTF-32 is not always correct.  */
  59       if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
  60         return "UTF-32BE";
  61       else
  62         return "UTF-32LE";
  63     }
  64   internal_error (__FILE__, __LINE__, _("unhandled c_string_type"));
  65 }
  66
  67 /* Classify ELTTYPE according to what kind of character it is.  Return
  68    the enum constant representing the character type.  Also set
  69    *ENCODING to the name of the character set to use when converting
  70    characters of this type in target BYTE_ORDER to the host character
  71    set.  */
  72
  73 static c_string_type
  74 classify_type (struct type *elttype, struct gdbarch *gdbarch,
  75                const char **encoding)
  76 {
  77   c_string_type result;
  78
  79   /* We loop because ELTTYPE may be a typedef, and we want to
  80      successively peel each typedef until we reach a type we
  81      understand.  We don't use CHECK_TYPEDEF because that will strip
  82      all typedefs at once -- but in C, wchar_t is itself a typedef, so
  83      that would do the wrong thing.  */
  84   while (elttype)
  85     {
  86       const char *name = TYPE_NAME (elttype);
  87
  88       if (TYPE_CODE (elttype) == TYPE_CODE_CHAR || !name)
  89         {
  90           result = C_CHAR;
  91           goto done;
  92         }
  93
  94       if (!strcmp (name, "wchar_t"))
  95         {
  96           result = C_WIDE_CHAR;
  97           goto done;
  98         }
  99
 100       if (!strcmp (name, "char16_t"))
 101         {
 102           result = C_CHAR_16;
 103           goto done;
 104         }
 105
 106       if (!strcmp (name, "char32_t"))
 107         {
 108           result = C_CHAR_32;
 109           goto done;
 110         }
 111
 112       if (TYPE_CODE (elttype) != TYPE_CODE_TYPEDEF)
 113         break;
 114
 115       /* Call for side effects.  */
 116       check_typedef (elttype);
 117
 118       if (TYPE_TARGET_TYPE (elttype))
 119         elttype = TYPE_TARGET_TYPE (elttype);
 120       else
 121         {
 122           /* Perhaps check_typedef did not update the target type.  In
 123              this case, force the lookup again and hope it works out.
 124              It never will for C, but it might for C++.  */
 125           elttype = check_typedef (elttype);
 126         }
 127     }
 128
 129   /* Punt.  */
 130   result = C_CHAR;
 131
 132  done:
 133   if (encoding)
 134     *encoding = charset_for_string_type (result, gdbarch);
 135
 136   return result;
 137 }
 138
 139 /* Print the character C on STREAM as part of the contents of a
 140    literal string whose delimiter is QUOTER.  Note that that format
 141    for printing characters and strings is language specific.  */
 142
 143 void
 144 c_emit_char (int c, struct type *type,
 145              struct ui_file *stream, int quoter)
 146 {
 147   const char *encoding;
 148
 149   classify_type (type, get_type_arch (type), &encoding);
 150   generic_emit_char (c, type, stream, quoter, encoding);
 151 }
 152
 153 void
 154 c_printchar (int c, struct type *type, struct ui_file *stream)
 155 {
 156   c_string_type str_type;
 157
 158   str_type = classify_type (type, get_type_arch (type), NULL);
 159   switch (str_type)
 160     {
 161     case C_CHAR:
 162       break;
 163     case C_WIDE_CHAR:
 164       fputc_filtered ('L', stream);
 165       break;
 166     case C_CHAR_16:
 167       fputc_filtered ('u', stream);
 168       break;
 169     case C_CHAR_32:
 170       fputc_filtered ('U', stream);
 171       break;
 172     }
 173
 174   fputc_filtered ('\'', stream);
 175   LA_EMIT_CHAR (c, type, stream, '\'');
 176   fputc_filtered ('\'', stream);
 177 }
 178
 179 /* Print the character string STRING, printing at most LENGTH
 180    characters.  LENGTH is -1 if the string is nul terminated.  Each
 181    character is WIDTH bytes long.  Printing stops early if the number
 182    hits print_max; repeat counts are printed as appropriate.  Print
 183    ellipses at the end if we had to stop before printing LENGTH
 184    characters, or if FORCE_ELLIPSES.  */
 185
 186 void
 187 c_printstr (struct ui_file *stream, struct type *type,
 188             const gdb_byte *string, unsigned int length,
 189             const char *user_encoding, int force_ellipses,
 190             const struct value_print_options *options)
 191 {
 192   c_string_type str_type;
 193   const char *type_encoding;
 194   const char *encoding;
 195
 196   str_type = (classify_type (type, get_type_arch (type), &type_encoding)
 197               & ~C_CHAR);
 198   switch (str_type)
 199     {
 200     case C_STRING:
 201       break;
 202     case C_WIDE_STRING:
 203       fputs_filtered ("L", stream);
 204       break;
 205     case C_STRING_16:
 206       fputs_filtered ("u", stream);
 207       break;
 208     case C_STRING_32:
 209       fputs_filtered ("U", stream);
 210       break;
 211     }
 212
 213   encoding = (user_encoding && *user_encoding) ? user_encoding : type_encoding;
 214
 215   generic_printstr (stream, type, string, length, encoding, force_ellipses,
 216                     '"', 1, options);
 217 }
 218
 219 /* Obtain a C string from the inferior storing it in a newly allocated
 220    buffer in BUFFER, which should be freed by the caller.  If the in-
 221    and out-parameter *LENGTH is specified at -1, the string is read
 222    until a null character of the appropriate width is found, otherwise
 223    the string is read to the length of characters specified.  The size
 224    of a character is determined by the length of the target type of
 225    the pointer or array.
 226
 227    If VALUE is an array with a known length, and *LENGTH is -1,
 228    the function will not read past the end of the array.  However, any
 229    declared size of the array is ignored if *LENGTH > 0.
 230
 231    On completion, *LENGTH will be set to the size of the string read in
 232    characters.  (If a length of -1 is specified, the length returned
 233    will not include the null character).  CHARSET is always set to the
 234    target charset.  */
 235
 236 void
 237 c_get_string (struct value *value, gdb::unique_xmalloc_ptr<gdb_byte> *buffer,
 238               int *length, struct type **char_type,
 239               const char **charset)
 240 {
 241   int err, width;
 242   unsigned int fetchlimit;
 243   struct type *type = check_typedef (value_type (value));
 244   struct type *element_type = TYPE_TARGET_TYPE (type);
 245   int req_length = *length;
 246   enum bfd_endian byte_order
 247     = gdbarch_byte_order (get_type_arch (type));
 248
 249   if (element_type == NULL)
 250     goto error;
 251
 252   if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
 253     {
 254       /* If we know the size of the array, we can use it as a limit on
 255          the number of characters to be fetched.  */
 256       if (TYPE_NFIELDS (type) == 1
 257           && TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_RANGE)
 258         {
 259           LONGEST low_bound, high_bound;
 260
 261           get_discrete_bounds (TYPE_FIELD_TYPE (type, 0),
 262                                &low_bound, &high_bound);
 263           fetchlimit = high_bound - low_bound + 1;
 264         }
 265       else
 266         fetchlimit = UINT_MAX;
 267     }
 268   else if (TYPE_CODE (type) == TYPE_CODE_PTR)
 269     fetchlimit = UINT_MAX;
 270   else
 271     /* We work only with arrays and pointers.  */
 272     goto error;
 273
 274   if (! c_textual_element_type (element_type, 0))
 275     goto error;
 276   classify_type (element_type, get_type_arch (element_type), charset);
 277   width = TYPE_LENGTH (element_type);
 278
 279   /* If the string lives in GDB's memory instead of the inferior's,
 280      then we just need to copy it to BUFFER.  Also, since such strings
 281      are arrays with known size, FETCHLIMIT will hold the size of the
 282      array.  */
 283   if ((VALUE_LVAL (value) == not_lval
 284        || VALUE_LVAL (value) == lval_internalvar)
 285       && fetchlimit != UINT_MAX)
 286     {
 287       int i;
 288       const gdb_byte *contents = value_contents (value);
 289
 290       /* If a length is specified, use that.  */
 291       if (*length >= 0)
 292         i  = *length;
 293       else
 294         /* Otherwise, look for a null character.  */
 295         for (i = 0; i < fetchlimit; i++)
 296           if (extract_unsigned_integer (contents + i * width,
 297                                         width, byte_order) == 0)
 298             break;
 299
 300       /* I is now either a user-defined length, the number of non-null
 301          characters, or FETCHLIMIT.  */
 302       *length = i * width;
 303       buffer->reset ((gdb_byte *) xmalloc (*length));
 304       memcpy (buffer->get (), contents, *length);
 305       err = 0;
 306     }
 307   else
 308     {
 309       CORE_ADDR addr = value_as_address (value);
 310
 311       /* Prior to the fix for PR 16196 read_string would ignore fetchlimit
 312          if length > 0.  The old "broken" behaviour is the behaviour we want:
 313          The caller may want to fetch 100 bytes from a variable length array
 314          implemented using the common idiom of having an array of length 1 at
 315          the end of a struct.  In this case we want to ignore the declared
 316          size of the array.  However, it's counterintuitive to implement that
 317          behaviour in read_string: what does fetchlimit otherwise mean if
 318          length > 0.  Therefore we implement the behaviour we want here:
 319          If *length > 0, don't specify a fetchlimit.  This preserves the
 320          previous behaviour.  We could move this check above where we know
 321          whether the array is declared with a fixed size, but we only want
 322          to apply this behaviour when calling read_string.  PR 16286.  */
 323       if (*length > 0)
 324         fetchlimit = UINT_MAX;
 325
 326       err = read_string (addr, *length, width, fetchlimit,
 327                          byte_order, buffer, length);
 328       if (err != 0)
 329         memory_error (TARGET_XFER_E_IO, addr);
 330     }
 331
 332   /* If the LENGTH is specified at -1, we want to return the string
 333      length up to the terminating null character.  If an actual length
 334      was specified, we want to return the length of exactly what was
 335      read.  */
 336   if (req_length == -1)
 337     /* If the last character is null, subtract it from LENGTH.  */
 338     if (*length > 0
 339         && extract_unsigned_integer (buffer->get () + *length - width,
 340                                      width, byte_order) == 0)
 341       *length -= width;
 342
 343   /* The read_string function will return the number of bytes read.
 344      If length returned from read_string was > 0, return the number of
 345      characters read by dividing the number of bytes by width.  */
 346   if (*length != 0)
 347      *length = *length / width;
 348
 349   *char_type = element_type;
 350
 351   return;
 352
 353  error:
 354   {
 355     std::string type_str = type_to_string (type);
 356     if (!type_str.empty ())
 357       {
 358         error (_("Trying to read string with inappropriate type `%s'."),
 359                type_str.c_str ());
 360       }
 361     else
 362       error (_("Trying to read string with inappropriate type."));
 363   }
 364 }
 365
 366 \f
 367 /* Evaluating C and C++ expressions.  */
 368
 369 /* Convert a UCN.  The digits of the UCN start at P and extend no
 370    farther than LIMIT.  DEST_CHARSET is the name of the character set
 371    into which the UCN should be converted.  The results are written to
 372    OUTPUT.  LENGTH is the maximum length of the UCN, either 4 or 8.
 373    Returns a pointer to just after the final digit of the UCN.  */
 374
 375 static char *
 376 convert_ucn (char *p, char *limit, const char *dest_charset,
 377              struct obstack *output, int length)
 378 {
 379   unsigned long result = 0;
 380   gdb_byte data[4];
 381   int i;
 382
 383   for (i = 0; i < length && p < limit && ISXDIGIT (*p); ++i, ++p)
 384     result = (result << 4) + host_hex_value (*p);
 385
 386   for (i = 3; i >= 0; --i)
 387     {
 388       data[i] = result & 0xff;
 389       result >>= 8;
 390     }
 391
 392   convert_between_encodings ("UTF-32BE", dest_charset, data,
 393                              4, 4, output, translit_none);
 394
 395   return p;
 396 }
 397
 398 /* Emit a character, VALUE, which was specified numerically, to
 399    OUTPUT.  TYPE is the target character type.  */
 400
 401 static void
 402 emit_numeric_character (struct type *type, unsigned long value,
 403                         struct obstack *output)
 404 {
 405   gdb_byte *buffer;
 406
 407   buffer = (gdb_byte *) alloca (TYPE_LENGTH (type));
 408   pack_long (buffer, type, value);
 409   obstack_grow (output, buffer, TYPE_LENGTH (type));
 410 }
 411
 412 /* Convert an octal escape sequence.  TYPE is the target character
 413    type.  The digits of the escape sequence begin at P and extend no
 414    farther than LIMIT.  The result is written to OUTPUT.  Returns a
 415    pointer to just after the final digit of the escape sequence.  */
 416
 417 static char *
 418 convert_octal (struct type *type, char *p,
 419                char *limit, struct obstack *output)
 420 {
 421   int i;
 422   unsigned long value = 0;
 423
 424   for (i = 0;
 425        i < 3 && p < limit && ISDIGIT (*p) && *p != '8' && *p != '9';
 426        ++i)
 427     {
 428       value = 8 * value + host_hex_value (*p);
 429       ++p;
 430     }
 431
 432   emit_numeric_character (type, value, output);
 433
 434   return p;
 435 }
 436
 437 /* Convert a hex escape sequence.  TYPE is the target character type.
 438    The digits of the escape sequence begin at P and extend no farther
 439    than LIMIT.  The result is written to OUTPUT.  Returns a pointer to
 440    just after the final digit of the escape sequence.  */
 441
 442 static char *
 443 convert_hex (struct type *type, char *p,
 444              char *limit, struct obstack *output)
 445 {
 446   unsigned long value = 0;
 447
 448   while (p < limit && ISXDIGIT (*p))
 449     {
 450       value = 16 * value + host_hex_value (*p);
 451       ++p;
 452     }
 453
 454   emit_numeric_character (type, value, output);
 455
 456   return p;
 457 }
 458
 459 #define ADVANCE                                 \
 460   do {                                          \
 461     ++p;                                        \
 462     if (p == limit)                             \
 463       error (_("Malformed escape sequence"));   \
 464   } while (0)
 465
 466 /* Convert an escape sequence to a target format.  TYPE is the target
 467    character type to use, and DEST_CHARSET is the name of the target
 468    character set.  The backslash of the escape sequence is at *P, and
 469    the escape sequence will not extend past LIMIT.  The results are
 470    written to OUTPUT.  Returns a pointer to just past the final
 471    character of the escape sequence.  */
 472
 473 static char *
 474 convert_escape (struct type *type, const char *dest_charset,
 475                 char *p, char *limit, struct obstack *output)
 476 {
 477   /* Skip the backslash.  */
 478   ADVANCE;
 479
 480   switch (*p)
 481     {
 482     case '\\':
 483       obstack_1grow (output, '\\');
 484       ++p;
 485       break;
 486
 487     case 'x':
 488       ADVANCE;
 489       if (!ISXDIGIT (*p))
 490         error (_("\\x used with no following hex digits."));
 491       p = convert_hex (type, p, limit, output);
 492       break;
 493
 494     case '0':
 495     case '1':
 496     case '2':
 497     case '3':
 498     case '4':
 499     case '5':
 500     case '6':
 501     case '7':
 502       p = convert_octal (type, p, limit, output);
 503       break;
 504
 505     case 'u':
 506     case 'U':
 507       {
 508         int length = *p == 'u' ? 4 : 8;
 509
 510         ADVANCE;
 511         if (!ISXDIGIT (*p))
 512           error (_("\\u used with no following hex digits"));
 513         p = convert_ucn (p, limit, dest_charset, output, length);
 514       }
 515     }
 516
 517   return p;
 518 }
 519
 520 /* Given a single string from a (C-specific) OP_STRING list, convert
 521    it to a target string, handling escape sequences specially.  The
 522    output is written to OUTPUT.  DATA is the input string, which has
 523    length LEN.  DEST_CHARSET is the name of the target character set,
 524    and TYPE is the type of target character to use.  */
 525
 526 static void
 527 parse_one_string (struct obstack *output, char *data, int len,
 528                   const char *dest_charset, struct type *type)
 529 {
 530   char *limit;
 531
 532   limit = data + len;
 533
 534   while (data < limit)
 535     {
 536       char *p = data;
 537
 538       /* Look for next escape, or the end of the input.  */
 539       while (p < limit && *p != '\\')
 540         ++p;
 541       /* If we saw a run of characters, convert them all.  */
 542       if (p > data)
 543         convert_between_encodings (host_charset (), dest_charset,
 544                                    (gdb_byte *) data, p - data, 1,
 545                                    output, translit_none);
 546       /* If we saw an escape, convert it.  */
 547       if (p < limit)
 548         p = convert_escape (type, dest_charset, p, limit, output);
 549       data = p;
 550     }
 551 }
 552
 553 /* Expression evaluator for the C language family.  Most operations
 554    are delegated to evaluate_subexp_standard; see that function for a
 555    description of the arguments.  */
 556
 557 struct value *
 558 evaluate_subexp_c (struct type *expect_type, struct expression *exp,
 559                    int *pos, enum noside noside)
 560 {
 561   enum exp_opcode op = exp->elts[*pos].opcode;
 562
 563   switch (op)
 564     {
 565     case OP_STRING:
 566       {
 567         int oplen, limit;
 568         struct type *type;
 569         struct value *result;
 570         c_string_type dest_type;
 571         const char *dest_charset;
 572         int satisfy_expected = 0;
 573
 574         auto_obstack output;
 575
 576         ++*pos;
 577         oplen = longest_to_int (exp->elts[*pos].longconst);
 578
 579         ++*pos;
 580         limit = *pos + BYTES_TO_EXP_ELEM (oplen + 1);
 581         dest_type = ((enum c_string_type_values)
 582                      longest_to_int (exp->elts[*pos].longconst));
 583         switch (dest_type & ~C_CHAR)
 584           {
 585           case C_STRING:
 586             type = language_string_char_type (exp->language_defn,
 587                                               exp->gdbarch);
 588             break;
 589           case C_WIDE_STRING:
 590             type = lookup_typename (exp->language_defn, exp->gdbarch,
 591                                     "wchar_t", NULL, 0);
 592             break;
 593           case C_STRING_16:
 594             type = lookup_typename (exp->language_defn, exp->gdbarch,
 595                                     "char16_t", NULL, 0);
 596             break;
 597           case C_STRING_32:
 598             type = lookup_typename (exp->language_defn, exp->gdbarch,
 599                                     "char32_t", NULL, 0);
 600             break;
 601           default:
 602             internal_error (__FILE__, __LINE__, _("unhandled c_string_type"));
 603           }
 604
 605         /* Ensure TYPE_LENGTH is valid for TYPE.  */
 606         check_typedef (type);
 607
 608         /* If the caller expects an array of some integral type,
 609            satisfy them.  If something odder is expected, rely on the
 610            caller to cast.  */
 611         if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_ARRAY)
 612           {
 613             struct type *element_type
 614               = check_typedef (TYPE_TARGET_TYPE (expect_type));
 615
 616             if (TYPE_CODE (element_type) == TYPE_CODE_INT
 617                 || TYPE_CODE (element_type) == TYPE_CODE_CHAR)
 618               {
 619                 type = element_type;
 620                 satisfy_expected = 1;
 621               }
 622           }
 623
 624         dest_charset = charset_for_string_type (dest_type, exp->gdbarch);
 625
 626         ++*pos;
 627         while (*pos < limit)
 628           {
 629             int len;
 630
 631             len = longest_to_int (exp->elts[*pos].longconst);
 632
 633             ++*pos;
 634             if (noside != EVAL_SKIP)
 635               parse_one_string (&output, &exp->elts[*pos].string, len,
 636                                 dest_charset, type);
 637             *pos += BYTES_TO_EXP_ELEM (len);
 638           }
 639
 640         /* Skip the trailing length and opcode.  */
 641         *pos += 2;
 642
 643         if (noside == EVAL_SKIP)
 644           {
 645             /* Return a dummy value of the appropriate type.  */
 646             if (expect_type != NULL)
 647               result = allocate_value (expect_type);
 648             else if ((dest_type & C_CHAR) != 0)
 649               result = allocate_value (type);
 650             else
 651               result = value_cstring ("", 0, type);
 652             return result;
 653           }
 654
 655         if ((dest_type & C_CHAR) != 0)
 656           {
 657             LONGEST value;
 658
 659             if (obstack_object_size (&output) != TYPE_LENGTH (type))
 660               error (_("Could not convert character "
 661                        "constant to target character set"));
 662             value = unpack_long (type, (gdb_byte *) obstack_base (&output));
 663             result = value_from_longest (type, value);
 664           }
 665         else
 666           {
 667             int i;
 668
 669             /* Write the terminating character.  */
 670             for (i = 0; i < TYPE_LENGTH (type); ++i)
 671               obstack_1grow (&output, 0);
 672
 673             if (satisfy_expected)
 674               {
 675                 LONGEST low_bound, high_bound;
 676                 int element_size = TYPE_LENGTH (type);
 677
 678                 if (get_discrete_bounds (TYPE_INDEX_TYPE (expect_type),
 679                                          &low_bound, &high_bound) < 0)
 680                   {
 681                     low_bound = 0;
 682                     high_bound = (TYPE_LENGTH (expect_type) / element_size) - 1;
 683                   }
 684                 if (obstack_object_size (&output) / element_size
 685                     > (high_bound - low_bound + 1))
 686                   error (_("Too many array elements"));
 687
 688                 result = allocate_value (expect_type);
 689                 memcpy (value_contents_raw (result), obstack_base (&output),
 690                         obstack_object_size (&output));
 691               }
 692             else
 693               result = value_cstring ((const char *) obstack_base (&output),
 694                                       obstack_object_size (&output),
 695                                       type);
 696           }
 697         return result;
 698       }
 699       break;
 700
 701     default:
 702       break;
 703     }
 704   return evaluate_subexp_standard (expect_type, exp, pos, noside);
 705 }
 706 \f
 707 /* la_watch_location_expression for C.  */
 708
 709 gdb::unique_xmalloc_ptr<char>
 710 c_watch_location_expression (struct type *type, CORE_ADDR addr)
 711 {
 712   type = check_typedef (TYPE_TARGET_TYPE (check_typedef (type)));
 713   std::string name = type_to_string (type);
 714   return gdb::unique_xmalloc_ptr<char>
 715     (xstrprintf ("* (%s *) %s", name.c_str (), core_addr_to_string (addr)));
 716 }
 717
 718 /* See c-lang.h.  */
 719
 720 bool
 721 c_is_string_type_p (struct type *type)
 722 {
 723   type = check_typedef (type);
 724   while (TYPE_CODE (type) == TYPE_CODE_REF)
 725     {
 726       type = TYPE_TARGET_TYPE (type);
 727       type = check_typedef (type);
 728     }
 729
 730   switch (TYPE_CODE (type))
 731     {
 732     case TYPE_CODE_ARRAY:
 733       {
 734         /* See if target type looks like a string.  */
 735         struct type *array_target_type = TYPE_TARGET_TYPE (type);
 736         return (TYPE_LENGTH (type) > 0
 737                 && TYPE_LENGTH (array_target_type) > 0
 738                 && c_textual_element_type (array_target_type, 0));
 739       }
 740     case TYPE_CODE_STRING:
 741       return true;
 742     case TYPE_CODE_PTR:
 743       {
 744         struct type *element_type = TYPE_TARGET_TYPE (type);
 745         return c_textual_element_type (element_type, 0);
 746       }
 747     default:
 748       break;
 749     }
 750
 751   return false;
 752 }
 753
 754 \f
 755 /* Table mapping opcodes into strings for printing operators
 756    and precedences of the operators.  */
 757
 758 const struct op_print c_op_print_tab[] =
 759 {
 760   {",", BINOP_COMMA, PREC_COMMA, 0},
 761   {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
 762   {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
 763   {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
 764   {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
 765   {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
 766   {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
 767   {"==", BINOP_EQUAL, PREC_EQUAL, 0},
 768   {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
 769   {"<=", BINOP_LEQ, PREC_ORDER, 0},
 770   {">=", BINOP_GEQ, PREC_ORDER, 0},
 771   {">", BINOP_GTR, PREC_ORDER, 0},
 772   {"<", BINOP_LESS, PREC_ORDER, 0},
 773   {">>", BINOP_RSH, PREC_SHIFT, 0},
 774   {"<<", BINOP_LSH, PREC_SHIFT, 0},
 775   {"+", BINOP_ADD, PREC_ADD, 0},
 776   {"-", BINOP_SUB, PREC_ADD, 0},
 777   {"*", BINOP_MUL, PREC_MUL, 0},
 778   {"/", BINOP_DIV, PREC_MUL, 0},
 779   {"%", BINOP_REM, PREC_MUL, 0},
 780   {"@", BINOP_REPEAT, PREC_REPEAT, 0},
 781   {"+", UNOP_PLUS, PREC_PREFIX, 0},
 782   {"-", UNOP_NEG, PREC_PREFIX, 0},
 783   {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
 784   {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
 785   {"*", UNOP_IND, PREC_PREFIX, 0},
 786   {"&", UNOP_ADDR, PREC_PREFIX, 0},
 787   {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
 788   {"alignof ", UNOP_ALIGNOF, PREC_PREFIX, 0},
 789   {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
 790   {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
 791   {NULL, OP_NULL, PREC_PREFIX, 0}
 792 };
 793 \f
 794 enum c_primitive_types {
 795   c_primitive_type_int,
 796   c_primitive_type_long,
 797   c_primitive_type_short,
 798   c_primitive_type_char,
 799   c_primitive_type_float,
 800   c_primitive_type_double,
 801   c_primitive_type_void,
 802   c_primitive_type_long_long,
 803   c_primitive_type_signed_char,
 804   c_primitive_type_unsigned_char,
 805   c_primitive_type_unsigned_short,
 806   c_primitive_type_unsigned_int,
 807   c_primitive_type_unsigned_long,
 808   c_primitive_type_unsigned_long_long,
 809   c_primitive_type_long_double,
 810   c_primitive_type_complex,
 811   c_primitive_type_double_complex,
 812   c_primitive_type_decfloat,
 813   c_primitive_type_decdouble,
 814   c_primitive_type_declong,
 815   nr_c_primitive_types
 816 };
 817
 818 void
 819 c_language_arch_info (struct gdbarch *gdbarch,
 820                       struct language_arch_info *lai)
 821 {
 822   const struct builtin_type *builtin = builtin_type (gdbarch);
 823
 824   lai->string_char_type = builtin->builtin_char;
 825   lai->primitive_type_vector
 826     = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_c_primitive_types + 1,
 827                               struct type *);
 828   lai->primitive_type_vector [c_primitive_type_int] = builtin->builtin_int;
 829   lai->primitive_type_vector [c_primitive_type_long] = builtin->builtin_long;
 830   lai->primitive_type_vector [c_primitive_type_short] = builtin->builtin_short;
 831   lai->primitive_type_vector [c_primitive_type_char] = builtin->builtin_char;
 832   lai->primitive_type_vector [c_primitive_type_float] = builtin->builtin_float;
 833   lai->primitive_type_vector [c_primitive_type_double] = builtin->builtin_double;
 834   lai->primitive_type_vector [c_primitive_type_void] = builtin->builtin_void;
 835   lai->primitive_type_vector [c_primitive_type_long_long] = builtin->builtin_long_long;
 836   lai->primitive_type_vector [c_primitive_type_signed_char] = builtin->builtin_signed_char;
 837   lai->primitive_type_vector [c_primitive_type_unsigned_char] = builtin->builtin_unsigned_char;
 838   lai->primitive_type_vector [c_primitive_type_unsigned_short] = builtin->builtin_unsigned_short;
 839   lai->primitive_type_vector [c_primitive_type_unsigned_int] = builtin->builtin_unsigned_int;
 840   lai->primitive_type_vector [c_primitive_type_unsigned_long] = builtin->builtin_unsigned_long;
 841   lai->primitive_type_vector [c_primitive_type_unsigned_long_long] = builtin->builtin_unsigned_long_long;
 842   lai->primitive_type_vector [c_primitive_type_long_double] = builtin->builtin_long_double;
 843   lai->primitive_type_vector [c_primitive_type_complex] = builtin->builtin_complex;
 844   lai->primitive_type_vector [c_primitive_type_double_complex] = builtin->builtin_double_complex;
 845   lai->primitive_type_vector [c_primitive_type_decfloat] = builtin->builtin_decfloat;
 846   lai->primitive_type_vector [c_primitive_type_decdouble] = builtin->builtin_decdouble;
 847   lai->primitive_type_vector [c_primitive_type_declong] = builtin->builtin_declong;
 848
 849   lai->bool_type_default = builtin->builtin_int;
 850 }
 851
 852 const struct exp_descriptor exp_descriptor_c =
 853 {
 854   print_subexp_standard,
 855   operator_length_standard,
 856   operator_check_standard,
 857   op_name_standard,
 858   dump_subexp_body_standard,
 859   evaluate_subexp_c
 860 };
 861
 862 static const char *c_extensions[] =
 863 {
 864   ".c", NULL
 865 };
 866
 867 extern const struct language_defn c_language_defn =
 868 {
 869   "c",                          /* Language name */
 870   "C",
 871   language_c,
 872   range_check_off,
 873   case_sensitive_on,
 874   array_row_major,
 875   macro_expansion_c,
 876   c_extensions,
 877   &exp_descriptor_c,
 878   c_parse,
 879   null_post_parser,
 880   c_printchar,                  /* Print a character constant */
 881   c_printstr,                   /* Function to print string constant */
 882   c_emit_char,                  /* Print a single char */
 883   c_print_type,                 /* Print a type using appropriate syntax */
 884   c_print_typedef,              /* Print a typedef using appropriate syntax */
 885   c_val_print,                  /* Print a value using appropriate syntax */
 886   c_value_print,                /* Print a top-level value */
 887   default_read_var_value,       /* la_read_var_value */
 888   NULL,                         /* Language specific skip_trampoline */
 889   NULL,                         /* name_of_this */
 890   true,                         /* la_store_sym_names_in_linkage_form_p */
 891   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
 892   basic_lookup_transparent_type,/* lookup_transparent_type */
 893   NULL,                         /* Language specific symbol demangler */
 894   NULL,
 895   NULL,                         /* Language specific
 896                                    class_name_from_physname */
 897   c_op_print_tab,               /* expression operators for printing */
 898   1,                            /* c-style arrays */
 899   0,                            /* String lower bound */
 900   default_word_break_characters,
 901   default_collect_symbol_completion_matches,
 902   c_language_arch_info,
 903   default_print_array_index,
 904   default_pass_by_reference,
 905   c_get_string,
 906   c_watch_location_expression,
 907   NULL,                         /* la_get_symbol_name_matcher */
 908   iterate_over_symbols,
 909   default_search_name_hash,
 910   &c_varobj_ops,
 911   c_get_compile_context,
 912   c_compute_program,
 913   c_is_string_type_p,
 914   "{...}"                       /* la_struct_too_deep_ellipsis */
 915 };
 916
 917 enum cplus_primitive_types {
 918   cplus_primitive_type_int,
 919   cplus_primitive_type_long,
 920   cplus_primitive_type_short,
 921   cplus_primitive_type_char,
 922   cplus_primitive_type_float,
 923   cplus_primitive_type_double,
 924   cplus_primitive_type_void,
 925   cplus_primitive_type_long_long,
 926   cplus_primitive_type_signed_char,
 927   cplus_primitive_type_unsigned_char,
 928   cplus_primitive_type_unsigned_short,
 929   cplus_primitive_type_unsigned_int,
 930   cplus_primitive_type_unsigned_long,
 931   cplus_primitive_type_unsigned_long_long,
 932   cplus_primitive_type_long_double,
 933   cplus_primitive_type_complex,
 934   cplus_primitive_type_double_complex,
 935   cplus_primitive_type_bool,
 936   cplus_primitive_type_decfloat,
 937   cplus_primitive_type_decdouble,
 938   cplus_primitive_type_declong,
 939   cplus_primitive_type_char16_t,
 940   cplus_primitive_type_char32_t,
 941   cplus_primitive_type_wchar_t,
 942   nr_cplus_primitive_types
 943 };
 944
 945 static void
 946 cplus_language_arch_info (struct gdbarch *gdbarch,
 947                           struct language_arch_info *lai)
 948 {
 949   const struct builtin_type *builtin = builtin_type (gdbarch);
 950
 951   lai->string_char_type = builtin->builtin_char;
 952   lai->primitive_type_vector
 953     = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_cplus_primitive_types + 1,
 954                               struct type *);
 955   lai->primitive_type_vector [cplus_primitive_type_int]
 956     = builtin->builtin_int;
 957   lai->primitive_type_vector [cplus_primitive_type_long]
 958     = builtin->builtin_long;
 959   lai->primitive_type_vector [cplus_primitive_type_short]
 960     = builtin->builtin_short;
 961   lai->primitive_type_vector [cplus_primitive_type_char]
 962     = builtin->builtin_char;
 963   lai->primitive_type_vector [cplus_primitive_type_float]
 964     = builtin->builtin_float;
 965   lai->primitive_type_vector [cplus_primitive_type_double]
 966     = builtin->builtin_double;
 967   lai->primitive_type_vector [cplus_primitive_type_void]
 968     = builtin->builtin_void;
 969   lai->primitive_type_vector [cplus_primitive_type_long_long]
 970     = builtin->builtin_long_long;
 971   lai->primitive_type_vector [cplus_primitive_type_signed_char]
 972     = builtin->builtin_signed_char;
 973   lai->primitive_type_vector [cplus_primitive_type_unsigned_char]
 974     = builtin->builtin_unsigned_char;
 975   lai->primitive_type_vector [cplus_primitive_type_unsigned_short]
 976     = builtin->builtin_unsigned_short;
 977   lai->primitive_type_vector [cplus_primitive_type_unsigned_int]
 978     = builtin->builtin_unsigned_int;
 979   lai->primitive_type_vector [cplus_primitive_type_unsigned_long]
 980     = builtin->builtin_unsigned_long;
 981   lai->primitive_type_vector [cplus_primitive_type_unsigned_long_long]
 982     = builtin->builtin_unsigned_long_long;
 983   lai->primitive_type_vector [cplus_primitive_type_long_double]
 984     = builtin->builtin_long_double;
 985   lai->primitive_type_vector [cplus_primitive_type_complex]
 986     = builtin->builtin_complex;
 987   lai->primitive_type_vector [cplus_primitive_type_double_complex]
 988     = builtin->builtin_double_complex;
 989   lai->primitive_type_vector [cplus_primitive_type_bool]
 990     = builtin->builtin_bool;
 991   lai->primitive_type_vector [cplus_primitive_type_decfloat]
 992     = builtin->builtin_decfloat;
 993   lai->primitive_type_vector [cplus_primitive_type_decdouble]
 994     = builtin->builtin_decdouble;
 995   lai->primitive_type_vector [cplus_primitive_type_declong]
 996     = builtin->builtin_declong;
 997   lai->primitive_type_vector [cplus_primitive_type_char16_t]
 998     = builtin->builtin_char16;
 999   lai->primitive_type_vector [cplus_primitive_type_char32_t]
1000     = builtin->builtin_char32;
1001   lai->primitive_type_vector [cplus_primitive_type_wchar_t]
1002     = builtin->builtin_wchar;
1003
1004   lai->bool_type_symbol = "bool";
1005   lai->bool_type_default = builtin->builtin_bool;
1006 }
1007
1008 static const char *cplus_extensions[] =
1009 {
1010   ".C", ".cc", ".cp", ".cpp", ".cxx", ".c++", NULL
1011 };
1012
1013 extern const struct language_defn cplus_language_defn =
1014 {
1015   "c++",                        /* Language name */
1016   "C++",
1017   language_cplus,
1018   range_check_off,
1019   case_sensitive_on,
1020   array_row_major,
1021   macro_expansion_c,
1022   cplus_extensions,
1023   &exp_descriptor_c,
1024   c_parse,
1025   null_post_parser,
1026   c_printchar,                  /* Print a character constant */
1027   c_printstr,                   /* Function to print string constant */
1028   c_emit_char,                  /* Print a single char */
1029   c_print_type,                 /* Print a type using appropriate syntax */
1030   c_print_typedef,              /* Print a typedef using appropriate syntax */
1031   c_val_print,                  /* Print a value using appropriate syntax */
1032   c_value_print,                /* Print a top-level value */
1033   default_read_var_value,       /* la_read_var_value */
1034   cplus_skip_trampoline,        /* Language specific skip_trampoline */
1035   "this",                       /* name_of_this */
1036   false,                        /* la_store_sym_names_in_linkage_form_p */
1037   cp_lookup_symbol_nonlocal,    /* lookup_symbol_nonlocal */
1038   cp_lookup_transparent_type,   /* lookup_transparent_type */
1039   gdb_demangle,                 /* Language specific symbol demangler */
1040   gdb_sniff_from_mangled_name,
1041   cp_class_name_from_physname,  /* Language specific
1042                                    class_name_from_physname */
1043   c_op_print_tab,               /* expression operators for printing */
1044   1,                            /* c-style arrays */
1045   0,                            /* String lower bound */
1046   default_word_break_characters,
1047   default_collect_symbol_completion_matches,
1048   cplus_language_arch_info,
1049   default_print_array_index,
1050   cp_pass_by_reference,
1051   c_get_string,
1052   c_watch_location_expression,
1053   cp_get_symbol_name_matcher,
1054   iterate_over_symbols,
1055   cp_search_name_hash,
1056   &cplus_varobj_ops,
1057   cplus_get_compile_context,
1058   cplus_compute_program,
1059   c_is_string_type_p,
1060   "{...}"                       /* la_struct_too_deep_ellipsis */
1061 };
1062
1063 static const char *asm_extensions[] =
1064 {
1065   ".s", ".sx", ".S", NULL
1066 };
1067
1068 extern const struct language_defn asm_language_defn =
1069 {
1070   "asm",                        /* Language name */
1071   "assembly",
1072   language_asm,
1073   range_check_off,
1074   case_sensitive_on,
1075   array_row_major,
1076   macro_expansion_c,
1077   asm_extensions,
1078   &exp_descriptor_c,
1079   c_parse,
1080   null_post_parser,
1081   c_printchar,                  /* Print a character constant */
1082   c_printstr,                   /* Function to print string constant */
1083   c_emit_char,                  /* Print a single char */
1084   c_print_type,                 /* Print a type using appropriate syntax */
1085   c_print_typedef,              /* Print a typedef using appropriate syntax */
1086   c_val_print,                  /* Print a value using appropriate syntax */
1087   c_value_print,                /* Print a top-level value */
1088   default_read_var_value,       /* la_read_var_value */
1089   NULL,                         /* Language specific skip_trampoline */
1090   NULL,                         /* name_of_this */
1091   true,                         /* la_store_sym_names_in_linkage_form_p */
1092   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1093   basic_lookup_transparent_type,/* lookup_transparent_type */
1094   NULL,                         /* Language specific symbol demangler */
1095   NULL,
1096   NULL,                         /* Language specific
1097                                    class_name_from_physname */
1098   c_op_print_tab,               /* expression operators for printing */
1099   1,                            /* c-style arrays */
1100   0,                            /* String lower bound */
1101   default_word_break_characters,
1102   default_collect_symbol_completion_matches,
1103   c_language_arch_info,         /* FIXME: la_language_arch_info.  */
1104   default_print_array_index,
1105   default_pass_by_reference,
1106   c_get_string,
1107   c_watch_location_expression,
1108   NULL,                         /* la_get_symbol_name_matcher */
1109   iterate_over_symbols,
1110   default_search_name_hash,
1111   &default_varobj_ops,
1112   NULL,
1113   NULL,
1114   c_is_string_type_p,
1115   "{...}"                       /* la_struct_too_deep_ellipsis */
1116 };
1117
1118 /* The following language_defn does not represent a real language.
1119    It just provides a minimal support a-la-C that should allow users
1120    to do some simple operations when debugging applications that use
1121    a language currently not supported by GDB.  */
1122
1123 extern const struct language_defn minimal_language_defn =
1124 {
1125   "minimal",                    /* Language name */
1126   "Minimal",
1127   language_minimal,
1128   range_check_off,
1129   case_sensitive_on,
1130   array_row_major,
1131   macro_expansion_c,
1132   NULL,
1133   &exp_descriptor_c,
1134   c_parse,
1135   null_post_parser,
1136   c_printchar,                  /* Print a character constant */
1137   c_printstr,                   /* Function to print string constant */
1138   c_emit_char,                  /* Print a single char */
1139   c_print_type,                 /* Print a type using appropriate syntax */
1140   c_print_typedef,              /* Print a typedef using appropriate syntax */
1141   c_val_print,                  /* Print a value using appropriate syntax */
1142   c_value_print,                /* Print a top-level value */
1143   default_read_var_value,       /* la_read_var_value */
1144   NULL,                         /* Language specific skip_trampoline */
1145   NULL,                         /* name_of_this */
1146   true,                         /* la_store_sym_names_in_linkage_form_p */
1147   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1148   basic_lookup_transparent_type,/* lookup_transparent_type */
1149   NULL,                         /* Language specific symbol demangler */
1150   NULL,
1151   NULL,                         /* Language specific
1152                                    class_name_from_physname */
1153   c_op_print_tab,               /* expression operators for printing */
1154   1,                            /* c-style arrays */
1155   0,                            /* String lower bound */
1156   default_word_break_characters,
1157   default_collect_symbol_completion_matches,
1158   c_language_arch_info,
1159   default_print_array_index,
1160   default_pass_by_reference,
1161   c_get_string,
1162   c_watch_location_expression,
1163   NULL,                         /* la_get_symbol_name_matcher */
1164   iterate_over_symbols,
1165   default_search_name_hash,
1166   &default_varobj_ops,
1167   NULL,
1168   NULL,
1169   c_is_string_type_p,
1170   "{...}"                       /* la_struct_too_deep_ellipsis */
1171 };