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