gdb/c-lang.c

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