gdb/c-lang.c

   1 /* C language support routines for GDB, the GNU debugger.
   2
   3    Copyright (C) 1992-2017 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 "valprint.h"
  29 #include "macroscope.h"
  30 #include "charset.h"
  31 #include "demangle.h"
  32 #include "cp-abi.h"
  33 #include "cp-support.h"
  34 #include "gdb_obstack.h"
  35 #include <ctype.h>
  36 #include "gdbcore.h"
  37
  38 extern void _initialize_c_language (void);
  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_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   if ((VALUE_LVAL (value) == not_lval
 285        || VALUE_LVAL (value) == lval_internalvar)
 286       && fetchlimit != UINT_MAX)
 287     {
 288       int i;
 289       const gdb_byte *contents = value_contents (value);
 290
 291       /* If a length is specified, use that.  */
 292       if (*length >= 0)
 293         i  = *length;
 294       else
 295         /* Otherwise, look for a null character.  */
 296         for (i = 0; i < fetchlimit; i++)
 297           if (extract_unsigned_integer (contents + i * width,
 298                                         width, byte_order) == 0)
 299             break;
 300
 301       /* I is now either a user-defined length, the number of non-null
 302          characters, or FETCHLIMIT.  */
 303       *length = i * width;
 304       *buffer = (gdb_byte *) xmalloc (*length);
 305       memcpy (*buffer, contents, *length);
 306       err = 0;
 307     }
 308   else
 309     {
 310       CORE_ADDR addr = value_as_address (value);
 311
 312       /* Prior to the fix for PR 16196 read_string would ignore fetchlimit
 313          if length > 0.  The old "broken" behaviour is the behaviour we want:
 314          The caller may want to fetch 100 bytes from a variable length array
 315          implemented using the common idiom of having an array of length 1 at
 316          the end of a struct.  In this case we want to ignore the declared
 317          size of the array.  However, it's counterintuitive to implement that
 318          behaviour in read_string: what does fetchlimit otherwise mean if
 319          length > 0.  Therefore we implement the behaviour we want here:
 320          If *length > 0, don't specify a fetchlimit.  This preserves the
 321          previous behaviour.  We could move this check above where we know
 322          whether the array is declared with a fixed size, but we only want
 323          to apply this behaviour when calling read_string.  PR 16286.  */
 324       if (*length > 0)
 325         fetchlimit = UINT_MAX;
 326
 327       err = read_string (addr, *length, width, fetchlimit,
 328                          byte_order, buffer, length);
 329       if (err != 0)
 330         {
 331           xfree (*buffer);
 332           memory_error (TARGET_XFER_E_IO, addr);
 333         }
 334     }
 335
 336   /* If the LENGTH is specified at -1, we want to return the string
 337      length up to the terminating null character.  If an actual length
 338      was specified, we want to return the length of exactly what was
 339      read.  */
 340   if (req_length == -1)
 341     /* If the last character is null, subtract it from LENGTH.  */
 342     if (*length > 0
 343         && extract_unsigned_integer (*buffer + *length - width,
 344                                      width, byte_order) == 0)
 345       *length -= width;
 346
 347   /* The read_string function will return the number of bytes read.
 348      If length returned from read_string was > 0, return the number of
 349      characters read by dividing the number of bytes by width.  */
 350   if (*length != 0)
 351      *length = *length / width;
 352
 353   *char_type = element_type;
 354
 355   return;
 356
 357  error:
 358   {
 359     std::string type_str = type_to_string (type);
 360     if (!type_str.empty ())
 361       {
 362         error (_("Trying to read string with inappropriate type `%s'."),
 363                type_str.c_str ());
 364       }
 365     else
 366       error (_("Trying to read string with inappropriate type."));
 367   }
 368 }
 369
 370 \f
 371 /* Evaluating C and C++ expressions.  */
 372
 373 /* Convert a UCN.  The digits of the UCN start at P and extend no
 374    farther than LIMIT.  DEST_CHARSET is the name of the character set
 375    into which the UCN should be converted.  The results are written to
 376    OUTPUT.  LENGTH is the maximum length of the UCN, either 4 or 8.
 377    Returns a pointer to just after the final digit of the UCN.  */
 378
 379 static char *
 380 convert_ucn (char *p, char *limit, const char *dest_charset,
 381              struct obstack *output, int length)
 382 {
 383   unsigned long result = 0;
 384   gdb_byte data[4];
 385   int i;
 386
 387   for (i = 0; i < length && p < limit && isxdigit (*p); ++i, ++p)
 388     result = (result << 4) + host_hex_value (*p);
 389
 390   for (i = 3; i >= 0; --i)
 391     {
 392       data[i] = result & 0xff;
 393       result >>= 8;
 394     }
 395
 396   convert_between_encodings ("UTF-32BE", dest_charset, data,
 397                              4, 4, output, translit_none);
 398
 399   return p;
 400 }
 401
 402 /* Emit a character, VALUE, which was specified numerically, to
 403    OUTPUT.  TYPE is the target character type.  */
 404
 405 static void
 406 emit_numeric_character (struct type *type, unsigned long value,
 407                         struct obstack *output)
 408 {
 409   gdb_byte *buffer;
 410
 411   buffer = (gdb_byte *) alloca (TYPE_LENGTH (type));
 412   pack_long (buffer, type, value);
 413   obstack_grow (output, buffer, TYPE_LENGTH (type));
 414 }
 415
 416 /* Convert an octal escape sequence.  TYPE is the target character
 417    type.  The digits of the escape sequence begin at P and extend no
 418    farther than LIMIT.  The result is written to OUTPUT.  Returns a
 419    pointer to just after the final digit of the escape sequence.  */
 420
 421 static char *
 422 convert_octal (struct type *type, char *p,
 423                char *limit, struct obstack *output)
 424 {
 425   int i;
 426   unsigned long value = 0;
 427
 428   for (i = 0;
 429        i < 3 && p < limit && isdigit (*p) && *p != '8' && *p != '9';
 430        ++i)
 431     {
 432       value = 8 * value + host_hex_value (*p);
 433       ++p;
 434     }
 435
 436   emit_numeric_character (type, value, output);
 437
 438   return p;
 439 }
 440
 441 /* Convert a hex escape sequence.  TYPE is the target character type.
 442    The digits of the escape sequence begin at P and extend no farther
 443    than LIMIT.  The result is written to OUTPUT.  Returns a pointer to
 444    just after the final digit of the escape sequence.  */
 445
 446 static char *
 447 convert_hex (struct type *type, char *p,
 448              char *limit, struct obstack *output)
 449 {
 450   unsigned long value = 0;
 451
 452   while (p < limit && isxdigit (*p))
 453     {
 454       value = 16 * value + host_hex_value (*p);
 455       ++p;
 456     }
 457
 458   emit_numeric_character (type, value, output);
 459
 460   return p;
 461 }
 462
 463 #define ADVANCE                                 \
 464   do {                                          \
 465     ++p;                                        \
 466     if (p == limit)                             \
 467       error (_("Malformed escape sequence"));   \
 468   } while (0)
 469
 470 /* Convert an escape sequence to a target format.  TYPE is the target
 471    character type to use, and DEST_CHARSET is the name of the target
 472    character set.  The backslash of the escape sequence is at *P, and
 473    the escape sequence will not extend past LIMIT.  The results are
 474    written to OUTPUT.  Returns a pointer to just past the final
 475    character of the escape sequence.  */
 476
 477 static char *
 478 convert_escape (struct type *type, const char *dest_charset,
 479                 char *p, char *limit, struct obstack *output)
 480 {
 481   /* Skip the backslash.  */
 482   ADVANCE;
 483
 484   switch (*p)
 485     {
 486     case '\\':
 487       obstack_1grow (output, '\\');
 488       ++p;
 489       break;
 490
 491     case 'x':
 492       ADVANCE;
 493       if (!isxdigit (*p))
 494         error (_("\\x used with no following hex digits."));
 495       p = convert_hex (type, p, limit, output);
 496       break;
 497
 498     case '0':
 499     case '1':
 500     case '2':
 501     case '3':
 502     case '4':
 503     case '5':
 504     case '6':
 505     case '7':
 506       p = convert_octal (type, p, limit, output);
 507       break;
 508
 509     case 'u':
 510     case 'U':
 511       {
 512         int length = *p == 'u' ? 4 : 8;
 513
 514         ADVANCE;
 515         if (!isxdigit (*p))
 516           error (_("\\u used with no following hex digits"));
 517         p = convert_ucn (p, limit, dest_charset, output, length);
 518       }
 519     }
 520
 521   return p;
 522 }
 523
 524 /* Given a single string from a (C-specific) OP_STRING list, convert
 525    it to a target string, handling escape sequences specially.  The
 526    output is written to OUTPUT.  DATA is the input string, which has
 527    length LEN.  DEST_CHARSET is the name of the target character set,
 528    and TYPE is the type of target character to use.  */
 529
 530 static void
 531 parse_one_string (struct obstack *output, char *data, int len,
 532                   const char *dest_charset, struct type *type)
 533 {
 534   char *limit;
 535
 536   limit = data + len;
 537
 538   while (data < limit)
 539     {
 540       char *p = data;
 541
 542       /* Look for next escape, or the end of the input.  */
 543       while (p < limit && *p != '\\')
 544         ++p;
 545       /* If we saw a run of characters, convert them all.  */
 546       if (p > data)
 547         convert_between_encodings (host_charset (), dest_charset,
 548                                    (gdb_byte *) data, p - data, 1,
 549                                    output, translit_none);
 550       /* If we saw an escape, convert it.  */
 551       if (p < limit)
 552         p = convert_escape (type, dest_charset, p, limit, output);
 553       data = p;
 554     }
 555 }
 556
 557 /* Expression evaluator for the C language family.  Most operations
 558    are delegated to evaluate_subexp_standard; see that function for a
 559    description of the arguments.  */
 560
 561 struct value *
 562 evaluate_subexp_c (struct type *expect_type, struct expression *exp,
 563                    int *pos, enum noside noside)
 564 {
 565   enum exp_opcode op = exp->elts[*pos].opcode;
 566
 567   switch (op)
 568     {
 569     case OP_STRING:
 570       {
 571         int oplen, limit;
 572         struct type *type;
 573         struct obstack output;
 574         struct cleanup *cleanup;
 575         struct value *result;
 576         c_string_type dest_type;
 577         const char *dest_charset;
 578         int satisfy_expected = 0;
 579
 580         obstack_init (&output);
 581         cleanup = make_cleanup_obstack_free (&output);
 582
 583         ++*pos;
 584         oplen = longest_to_int (exp->elts[*pos].longconst);
 585
 586         ++*pos;
 587         limit = *pos + BYTES_TO_EXP_ELEM (oplen + 1);
 588         dest_type = ((enum c_string_type_values)
 589                      longest_to_int (exp->elts[*pos].longconst));
 590         switch (dest_type & ~C_CHAR)
 591           {
 592           case C_STRING:
 593             type = language_string_char_type (exp->language_defn,
 594                                               exp->gdbarch);
 595             break;
 596           case C_WIDE_STRING:
 597             type = lookup_typename (exp->language_defn, exp->gdbarch,
 598                                     "wchar_t", NULL, 0);
 599             break;
 600           case C_STRING_16:
 601             type = lookup_typename (exp->language_defn, exp->gdbarch,
 602                                     "char16_t", NULL, 0);
 603             break;
 604           case C_STRING_32:
 605             type = lookup_typename (exp->language_defn, exp->gdbarch,
 606                                     "char32_t", NULL, 0);
 607             break;
 608           default:
 609             internal_error (__FILE__, __LINE__, _("unhandled c_string_type"));
 610           }
 611
 612         /* Ensure TYPE_LENGTH is valid for TYPE.  */
 613         check_typedef (type);
 614
 615         /* If the caller expects an array of some integral type,
 616            satisfy them.  If something odder is expected, rely on the
 617            caller to cast.  */
 618         if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_ARRAY)
 619           {
 620             struct type *element_type
 621               = check_typedef (TYPE_TARGET_TYPE (expect_type));
 622
 623             if (TYPE_CODE (element_type) == TYPE_CODE_INT
 624                 || TYPE_CODE (element_type) == TYPE_CODE_CHAR)
 625               {
 626                 type = element_type;
 627                 satisfy_expected = 1;
 628               }
 629           }
 630
 631         dest_charset = charset_for_string_type (dest_type, exp->gdbarch);
 632
 633         ++*pos;
 634         while (*pos < limit)
 635           {
 636             int len;
 637
 638             len = longest_to_int (exp->elts[*pos].longconst);
 639
 640             ++*pos;
 641             if (noside != EVAL_SKIP)
 642               parse_one_string (&output, &exp->elts[*pos].string, len,
 643                                 dest_charset, type);
 644             *pos += BYTES_TO_EXP_ELEM (len);
 645           }
 646
 647         /* Skip the trailing length and opcode.  */
 648         *pos += 2;
 649
 650         if (noside == EVAL_SKIP)
 651           {
 652             /* Return a dummy value of the appropriate type.  */
 653             if (expect_type != NULL)
 654               result = allocate_value (expect_type);
 655             else if ((dest_type & C_CHAR) != 0)
 656               result = allocate_value (type);
 657             else
 658               result = value_cstring ("", 0, type);
 659             do_cleanups (cleanup);
 660             return result;
 661           }
 662
 663         if ((dest_type & C_CHAR) != 0)
 664           {
 665             LONGEST value;
 666
 667             if (obstack_object_size (&output) != TYPE_LENGTH (type))
 668               error (_("Could not convert character "
 669                        "constant to target character set"));
 670             value = unpack_long (type, (gdb_byte *) obstack_base (&output));
 671             result = value_from_longest (type, value);
 672           }
 673         else
 674           {
 675             int i;
 676
 677             /* Write the terminating character.  */
 678             for (i = 0; i < TYPE_LENGTH (type); ++i)
 679               obstack_1grow (&output, 0);
 680
 681             if (satisfy_expected)
 682               {
 683                 LONGEST low_bound, high_bound;
 684                 int element_size = TYPE_LENGTH (type);
 685
 686                 if (get_discrete_bounds (TYPE_INDEX_TYPE (expect_type),
 687                                          &low_bound, &high_bound) < 0)
 688                   {
 689                     low_bound = 0;
 690                     high_bound = (TYPE_LENGTH (expect_type) / element_size) - 1;
 691                   }
 692                 if (obstack_object_size (&output) / element_size
 693                     > (high_bound - low_bound + 1))
 694                   error (_("Too many array elements"));
 695
 696                 result = allocate_value (expect_type);
 697                 memcpy (value_contents_raw (result), obstack_base (&output),
 698                         obstack_object_size (&output));
 699               }
 700             else
 701               result = value_cstring ((const char *) obstack_base (&output),
 702                                       obstack_object_size (&output),
 703                                       type);
 704           }
 705         do_cleanups (cleanup);
 706         return result;
 707       }
 708       break;
 709
 710     default:
 711       break;
 712     }
 713   return evaluate_subexp_standard (expect_type, exp, pos, noside);
 714 }
 715 \f
 716 /* la_watch_location_expression for C.  */
 717
 718 gdb::unique_xmalloc_ptr<char>
 719 c_watch_location_expression (struct type *type, CORE_ADDR addr)
 720 {
 721   type = check_typedef (TYPE_TARGET_TYPE (check_typedef (type)));
 722   std::string name = type_to_string (type);
 723   return gdb::unique_xmalloc_ptr<char>
 724     (xstrprintf ("* (%s *) %s", name.c_str (), core_addr_to_string (addr)));
 725 }
 726
 727 \f
 728 /* Table mapping opcodes into strings for printing operators
 729    and precedences of the operators.  */
 730
 731 const struct op_print c_op_print_tab[] =
 732 {
 733   {",", BINOP_COMMA, PREC_COMMA, 0},
 734   {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
 735   {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
 736   {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
 737   {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
 738   {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
 739   {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
 740   {"==", BINOP_EQUAL, PREC_EQUAL, 0},
 741   {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
 742   {"<=", BINOP_LEQ, PREC_ORDER, 0},
 743   {">=", BINOP_GEQ, PREC_ORDER, 0},
 744   {">", BINOP_GTR, PREC_ORDER, 0},
 745   {"<", BINOP_LESS, PREC_ORDER, 0},
 746   {">>", BINOP_RSH, PREC_SHIFT, 0},
 747   {"<<", BINOP_LSH, PREC_SHIFT, 0},
 748   {"+", BINOP_ADD, PREC_ADD, 0},
 749   {"-", BINOP_SUB, PREC_ADD, 0},
 750   {"*", BINOP_MUL, PREC_MUL, 0},
 751   {"/", BINOP_DIV, PREC_MUL, 0},
 752   {"%", BINOP_REM, PREC_MUL, 0},
 753   {"@", BINOP_REPEAT, PREC_REPEAT, 0},
 754   {"+", UNOP_PLUS, PREC_PREFIX, 0},
 755   {"-", UNOP_NEG, PREC_PREFIX, 0},
 756   {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
 757   {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
 758   {"*", UNOP_IND, PREC_PREFIX, 0},
 759   {"&", UNOP_ADDR, PREC_PREFIX, 0},
 760   {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
 761   {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
 762   {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
 763   {NULL, OP_NULL, PREC_PREFIX, 0}
 764 };
 765 \f
 766 enum c_primitive_types {
 767   c_primitive_type_int,
 768   c_primitive_type_long,
 769   c_primitive_type_short,
 770   c_primitive_type_char,
 771   c_primitive_type_float,
 772   c_primitive_type_double,
 773   c_primitive_type_void,
 774   c_primitive_type_long_long,
 775   c_primitive_type_signed_char,
 776   c_primitive_type_unsigned_char,
 777   c_primitive_type_unsigned_short,
 778   c_primitive_type_unsigned_int,
 779   c_primitive_type_unsigned_long,
 780   c_primitive_type_unsigned_long_long,
 781   c_primitive_type_long_double,
 782   c_primitive_type_complex,
 783   c_primitive_type_double_complex,
 784   c_primitive_type_decfloat,
 785   c_primitive_type_decdouble,
 786   c_primitive_type_declong,
 787   nr_c_primitive_types
 788 };
 789
 790 void
 791 c_language_arch_info (struct gdbarch *gdbarch,
 792                       struct language_arch_info *lai)
 793 {
 794   const struct builtin_type *builtin = builtin_type (gdbarch);
 795
 796   lai->string_char_type = builtin->builtin_char;
 797   lai->primitive_type_vector
 798     = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_c_primitive_types + 1,
 799                               struct type *);
 800   lai->primitive_type_vector [c_primitive_type_int] = builtin->builtin_int;
 801   lai->primitive_type_vector [c_primitive_type_long] = builtin->builtin_long;
 802   lai->primitive_type_vector [c_primitive_type_short] = builtin->builtin_short;
 803   lai->primitive_type_vector [c_primitive_type_char] = builtin->builtin_char;
 804   lai->primitive_type_vector [c_primitive_type_float] = builtin->builtin_float;
 805   lai->primitive_type_vector [c_primitive_type_double] = builtin->builtin_double;
 806   lai->primitive_type_vector [c_primitive_type_void] = builtin->builtin_void;
 807   lai->primitive_type_vector [c_primitive_type_long_long] = builtin->builtin_long_long;
 808   lai->primitive_type_vector [c_primitive_type_signed_char] = builtin->builtin_signed_char;
 809   lai->primitive_type_vector [c_primitive_type_unsigned_char] = builtin->builtin_unsigned_char;
 810   lai->primitive_type_vector [c_primitive_type_unsigned_short] = builtin->builtin_unsigned_short;
 811   lai->primitive_type_vector [c_primitive_type_unsigned_int] = builtin->builtin_unsigned_int;
 812   lai->primitive_type_vector [c_primitive_type_unsigned_long] = builtin->builtin_unsigned_long;
 813   lai->primitive_type_vector [c_primitive_type_unsigned_long_long] = builtin->builtin_unsigned_long_long;
 814   lai->primitive_type_vector [c_primitive_type_long_double] = builtin->builtin_long_double;
 815   lai->primitive_type_vector [c_primitive_type_complex] = builtin->builtin_complex;
 816   lai->primitive_type_vector [c_primitive_type_double_complex] = builtin->builtin_double_complex;
 817   lai->primitive_type_vector [c_primitive_type_decfloat] = builtin->builtin_decfloat;
 818   lai->primitive_type_vector [c_primitive_type_decdouble] = builtin->builtin_decdouble;
 819   lai->primitive_type_vector [c_primitive_type_declong] = builtin->builtin_declong;
 820
 821   lai->bool_type_default = builtin->builtin_int;
 822 }
 823
 824 const struct exp_descriptor exp_descriptor_c =
 825 {
 826   print_subexp_standard,
 827   operator_length_standard,
 828   operator_check_standard,
 829   op_name_standard,
 830   dump_subexp_body_standard,
 831   evaluate_subexp_c
 832 };
 833
 834 static const char *c_extensions[] =
 835 {
 836   ".c", NULL
 837 };
 838
 839 const struct language_defn c_language_defn =
 840 {
 841   "c",                          /* Language name */
 842   "C",
 843   language_c,
 844   range_check_off,
 845   case_sensitive_on,
 846   array_row_major,
 847   macro_expansion_c,
 848   c_extensions,
 849   &exp_descriptor_c,
 850   c_parse,
 851   c_yyerror,
 852   null_post_parser,
 853   c_printchar,                  /* Print a character constant */
 854   c_printstr,                   /* Function to print string constant */
 855   c_emit_char,                  /* Print a single char */
 856   c_print_type,                 /* Print a type using appropriate syntax */
 857   c_print_typedef,              /* Print a typedef using appropriate syntax */
 858   c_val_print,                  /* Print a value using appropriate syntax */
 859   c_value_print,                /* Print a top-level value */
 860   default_read_var_value,       /* la_read_var_value */
 861   NULL,                         /* Language specific skip_trampoline */
 862   NULL,                         /* name_of_this */
 863   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
 864   basic_lookup_transparent_type,/* lookup_transparent_type */
 865   NULL,                         /* Language specific symbol demangler */
 866   NULL,
 867   NULL,                         /* Language specific
 868                                    class_name_from_physname */
 869   c_op_print_tab,               /* expression operators for printing */
 870   1,                            /* c-style arrays */
 871   0,                            /* String lower bound */
 872   default_word_break_characters,
 873   default_make_symbol_completion_list,
 874   c_language_arch_info,
 875   default_print_array_index,
 876   default_pass_by_reference,
 877   c_get_string,
 878   c_watch_location_expression,
 879   NULL,                         /* la_get_symbol_name_cmp */
 880   iterate_over_symbols,
 881   &c_varobj_ops,
 882   c_get_compile_context,
 883   c_compute_program,
 884   LANG_MAGIC
 885 };
 886
 887 enum cplus_primitive_types {
 888   cplus_primitive_type_int,
 889   cplus_primitive_type_long,
 890   cplus_primitive_type_short,
 891   cplus_primitive_type_char,
 892   cplus_primitive_type_float,
 893   cplus_primitive_type_double,
 894   cplus_primitive_type_void,
 895   cplus_primitive_type_long_long,
 896   cplus_primitive_type_signed_char,
 897   cplus_primitive_type_unsigned_char,
 898   cplus_primitive_type_unsigned_short,
 899   cplus_primitive_type_unsigned_int,
 900   cplus_primitive_type_unsigned_long,
 901   cplus_primitive_type_unsigned_long_long,
 902   cplus_primitive_type_long_double,
 903   cplus_primitive_type_complex,
 904   cplus_primitive_type_double_complex,
 905   cplus_primitive_type_bool,
 906   cplus_primitive_type_decfloat,
 907   cplus_primitive_type_decdouble,
 908   cplus_primitive_type_declong,
 909   cplus_primitive_type_char16_t,
 910   cplus_primitive_type_char32_t,
 911   cplus_primitive_type_wchar_t,
 912   nr_cplus_primitive_types
 913 };
 914
 915 static void
 916 cplus_language_arch_info (struct gdbarch *gdbarch,
 917                           struct language_arch_info *lai)
 918 {
 919   const struct builtin_type *builtin = builtin_type (gdbarch);
 920
 921   lai->string_char_type = builtin->builtin_char;
 922   lai->primitive_type_vector
 923     = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_cplus_primitive_types + 1,
 924                               struct type *);
 925   lai->primitive_type_vector [cplus_primitive_type_int]
 926     = builtin->builtin_int;
 927   lai->primitive_type_vector [cplus_primitive_type_long]
 928     = builtin->builtin_long;
 929   lai->primitive_type_vector [cplus_primitive_type_short]
 930     = builtin->builtin_short;
 931   lai->primitive_type_vector [cplus_primitive_type_char]
 932     = builtin->builtin_char;
 933   lai->primitive_type_vector [cplus_primitive_type_float]
 934     = builtin->builtin_float;
 935   lai->primitive_type_vector [cplus_primitive_type_double]
 936     = builtin->builtin_double;
 937   lai->primitive_type_vector [cplus_primitive_type_void]
 938     = builtin->builtin_void;
 939   lai->primitive_type_vector [cplus_primitive_type_long_long]
 940     = builtin->builtin_long_long;
 941   lai->primitive_type_vector [cplus_primitive_type_signed_char]
 942     = builtin->builtin_signed_char;
 943   lai->primitive_type_vector [cplus_primitive_type_unsigned_char]
 944     = builtin->builtin_unsigned_char;
 945   lai->primitive_type_vector [cplus_primitive_type_unsigned_short]
 946     = builtin->builtin_unsigned_short;
 947   lai->primitive_type_vector [cplus_primitive_type_unsigned_int]
 948     = builtin->builtin_unsigned_int;
 949   lai->primitive_type_vector [cplus_primitive_type_unsigned_long]
 950     = builtin->builtin_unsigned_long;
 951   lai->primitive_type_vector [cplus_primitive_type_unsigned_long_long]
 952     = builtin->builtin_unsigned_long_long;
 953   lai->primitive_type_vector [cplus_primitive_type_long_double]
 954     = builtin->builtin_long_double;
 955   lai->primitive_type_vector [cplus_primitive_type_complex]
 956     = builtin->builtin_complex;
 957   lai->primitive_type_vector [cplus_primitive_type_double_complex]
 958     = builtin->builtin_double_complex;
 959   lai->primitive_type_vector [cplus_primitive_type_bool]
 960     = builtin->builtin_bool;
 961   lai->primitive_type_vector [cplus_primitive_type_decfloat]
 962     = builtin->builtin_decfloat;
 963   lai->primitive_type_vector [cplus_primitive_type_decdouble]
 964     = builtin->builtin_decdouble;
 965   lai->primitive_type_vector [cplus_primitive_type_declong]
 966     = builtin->builtin_declong;
 967   lai->primitive_type_vector [cplus_primitive_type_char16_t]
 968     = builtin->builtin_char16;
 969   lai->primitive_type_vector [cplus_primitive_type_char32_t]
 970     = builtin->builtin_char32;
 971   lai->primitive_type_vector [cplus_primitive_type_wchar_t]
 972     = builtin->builtin_wchar;
 973
 974   lai->bool_type_symbol = "bool";
 975   lai->bool_type_default = builtin->builtin_bool;
 976 }
 977
 978 static const char *cplus_extensions[] =
 979 {
 980   ".C", ".cc", ".cp", ".cpp", ".cxx", ".c++", NULL
 981 };
 982
 983 const struct language_defn cplus_language_defn =
 984 {
 985   "c++",                        /* Language name */
 986   "C++",
 987   language_cplus,
 988   range_check_off,
 989   case_sensitive_on,
 990   array_row_major,
 991   macro_expansion_c,
 992   cplus_extensions,
 993   &exp_descriptor_c,
 994   c_parse,
 995   c_yyerror,
 996   null_post_parser,
 997   c_printchar,                  /* Print a character constant */
 998   c_printstr,                   /* Function to print string constant */
 999   c_emit_char,                  /* Print a single char */
1000   c_print_type,                 /* Print a type using appropriate syntax */
1001   c_print_typedef,              /* Print a typedef using appropriate syntax */
1002   c_val_print,                  /* Print a value using appropriate syntax */
1003   c_value_print,                /* Print a top-level value */
1004   default_read_var_value,       /* la_read_var_value */
1005   cplus_skip_trampoline,        /* Language specific skip_trampoline */
1006   "this",                       /* name_of_this */
1007   cp_lookup_symbol_nonlocal,    /* lookup_symbol_nonlocal */
1008   cp_lookup_transparent_type,   /* lookup_transparent_type */
1009   gdb_demangle,                 /* Language specific symbol demangler */
1010   gdb_sniff_from_mangled_name,
1011   cp_class_name_from_physname,  /* Language specific
1012                                    class_name_from_physname */
1013   c_op_print_tab,               /* expression operators for printing */
1014   1,                            /* c-style arrays */
1015   0,                            /* String lower bound */
1016   default_word_break_characters,
1017   default_make_symbol_completion_list,
1018   cplus_language_arch_info,
1019   default_print_array_index,
1020   cp_pass_by_reference,
1021   c_get_string,
1022   c_watch_location_expression,
1023   NULL,                         /* la_get_symbol_name_cmp */
1024   iterate_over_symbols,
1025   &cplus_varobj_ops,
1026   NULL,
1027   NULL,
1028   LANG_MAGIC
1029 };
1030
1031 static const char *asm_extensions[] =
1032 {
1033   ".s", ".sx", ".S", NULL
1034 };
1035
1036 const struct language_defn asm_language_defn =
1037 {
1038   "asm",                        /* Language name */
1039   "assembly",
1040   language_asm,
1041   range_check_off,
1042   case_sensitive_on,
1043   array_row_major,
1044   macro_expansion_c,
1045   asm_extensions,
1046   &exp_descriptor_c,
1047   c_parse,
1048   c_yyerror,
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   NULL,                         /* Language specific skip_trampoline */
1059   NULL,                         /* name_of_this */
1060   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1061   basic_lookup_transparent_type,/* lookup_transparent_type */
1062   NULL,                         /* Language specific symbol demangler */
1063   NULL,
1064   NULL,                         /* Language specific
1065                                    class_name_from_physname */
1066   c_op_print_tab,               /* expression operators for printing */
1067   1,                            /* c-style arrays */
1068   0,                            /* String lower bound */
1069   default_word_break_characters,
1070   default_make_symbol_completion_list,
1071   c_language_arch_info,         /* FIXME: la_language_arch_info.  */
1072   default_print_array_index,
1073   default_pass_by_reference,
1074   c_get_string,
1075   c_watch_location_expression,
1076   NULL,                         /* la_get_symbol_name_cmp */
1077   iterate_over_symbols,
1078   &default_varobj_ops,
1079   NULL,
1080   NULL,
1081   LANG_MAGIC
1082 };
1083
1084 /* The following language_defn does not represent a real language.
1085    It just provides a minimal support a-la-C that should allow users
1086    to do some simple operations when debugging applications that use
1087    a language currently not supported by GDB.  */
1088
1089 const struct language_defn minimal_language_defn =
1090 {
1091   "minimal",                    /* Language name */
1092   "Minimal",
1093   language_minimal,
1094   range_check_off,
1095   case_sensitive_on,
1096   array_row_major,
1097   macro_expansion_c,
1098   NULL,
1099   &exp_descriptor_c,
1100   c_parse,
1101   c_yyerror,
1102   null_post_parser,
1103   c_printchar,                  /* Print a character constant */
1104   c_printstr,                   /* Function to print string constant */
1105   c_emit_char,                  /* Print a single char */
1106   c_print_type,                 /* Print a type using appropriate syntax */
1107   c_print_typedef,              /* Print a typedef using appropriate syntax */
1108   c_val_print,                  /* Print a value using appropriate syntax */
1109   c_value_print,                /* Print a top-level value */
1110   default_read_var_value,       /* la_read_var_value */
1111   NULL,                         /* Language specific skip_trampoline */
1112   NULL,                         /* name_of_this */
1113   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1114   basic_lookup_transparent_type,/* lookup_transparent_type */
1115   NULL,                         /* Language specific symbol demangler */
1116   NULL,
1117   NULL,                         /* Language specific
1118                                    class_name_from_physname */
1119   c_op_print_tab,               /* expression operators for printing */
1120   1,                            /* c-style arrays */
1121   0,                            /* String lower bound */
1122   default_word_break_characters,
1123   default_make_symbol_completion_list,
1124   c_language_arch_info,
1125   default_print_array_index,
1126   default_pass_by_reference,
1127   c_get_string,
1128   c_watch_location_expression,
1129   NULL,                         /* la_get_symbol_name_cmp */
1130   iterate_over_symbols,
1131   &default_varobj_ops,
1132   NULL,
1133   NULL,
1134   LANG_MAGIC
1135 };
1136
1137 void
1138 _initialize_c_language (void)
1139 {
1140   add_language (&c_language_defn);
1141   add_language (&cplus_language_defn);
1142   add_language (&asm_language_defn);
1143   add_language (&minimal_language_defn);
1144 }