gdb/c-lang.c

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