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