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   LANG_MAGIC
 878 };
 879
 880 enum cplus_primitive_types {
 881   cplus_primitive_type_int,
 882   cplus_primitive_type_long,
 883   cplus_primitive_type_short,
 884   cplus_primitive_type_char,
 885   cplus_primitive_type_float,
 886   cplus_primitive_type_double,
 887   cplus_primitive_type_void,
 888   cplus_primitive_type_long_long,
 889   cplus_primitive_type_signed_char,
 890   cplus_primitive_type_unsigned_char,
 891   cplus_primitive_type_unsigned_short,
 892   cplus_primitive_type_unsigned_int,
 893   cplus_primitive_type_unsigned_long,
 894   cplus_primitive_type_unsigned_long_long,
 895   cplus_primitive_type_long_double,
 896   cplus_primitive_type_complex,
 897   cplus_primitive_type_double_complex,
 898   cplus_primitive_type_bool,
 899   cplus_primitive_type_decfloat,
 900   cplus_primitive_type_decdouble,
 901   cplus_primitive_type_declong,
 902   cplus_primitive_type_char16_t,
 903   cplus_primitive_type_char32_t,
 904   cplus_primitive_type_wchar_t,
 905   nr_cplus_primitive_types
 906 };
 907
 908 static void
 909 cplus_language_arch_info (struct gdbarch *gdbarch,
 910                           struct language_arch_info *lai)
 911 {
 912   const struct builtin_type *builtin = builtin_type (gdbarch);
 913
 914   lai->string_char_type = builtin->builtin_char;
 915   lai->primitive_type_vector
 916     = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_cplus_primitive_types + 1,
 917                               struct type *);
 918   lai->primitive_type_vector [cplus_primitive_type_int]
 919     = builtin->builtin_int;
 920   lai->primitive_type_vector [cplus_primitive_type_long]
 921     = builtin->builtin_long;
 922   lai->primitive_type_vector [cplus_primitive_type_short]
 923     = builtin->builtin_short;
 924   lai->primitive_type_vector [cplus_primitive_type_char]
 925     = builtin->builtin_char;
 926   lai->primitive_type_vector [cplus_primitive_type_float]
 927     = builtin->builtin_float;
 928   lai->primitive_type_vector [cplus_primitive_type_double]
 929     = builtin->builtin_double;
 930   lai->primitive_type_vector [cplus_primitive_type_void]
 931     = builtin->builtin_void;
 932   lai->primitive_type_vector [cplus_primitive_type_long_long]
 933     = builtin->builtin_long_long;
 934   lai->primitive_type_vector [cplus_primitive_type_signed_char]
 935     = builtin->builtin_signed_char;
 936   lai->primitive_type_vector [cplus_primitive_type_unsigned_char]
 937     = builtin->builtin_unsigned_char;
 938   lai->primitive_type_vector [cplus_primitive_type_unsigned_short]
 939     = builtin->builtin_unsigned_short;
 940   lai->primitive_type_vector [cplus_primitive_type_unsigned_int]
 941     = builtin->builtin_unsigned_int;
 942   lai->primitive_type_vector [cplus_primitive_type_unsigned_long]
 943     = builtin->builtin_unsigned_long;
 944   lai->primitive_type_vector [cplus_primitive_type_unsigned_long_long]
 945     = builtin->builtin_unsigned_long_long;
 946   lai->primitive_type_vector [cplus_primitive_type_long_double]
 947     = builtin->builtin_long_double;
 948   lai->primitive_type_vector [cplus_primitive_type_complex]
 949     = builtin->builtin_complex;
 950   lai->primitive_type_vector [cplus_primitive_type_double_complex]
 951     = builtin->builtin_double_complex;
 952   lai->primitive_type_vector [cplus_primitive_type_bool]
 953     = builtin->builtin_bool;
 954   lai->primitive_type_vector [cplus_primitive_type_decfloat]
 955     = builtin->builtin_decfloat;
 956   lai->primitive_type_vector [cplus_primitive_type_decdouble]
 957     = builtin->builtin_decdouble;
 958   lai->primitive_type_vector [cplus_primitive_type_declong]
 959     = builtin->builtin_declong;
 960   lai->primitive_type_vector [cplus_primitive_type_char16_t]
 961     = builtin->builtin_char16;
 962   lai->primitive_type_vector [cplus_primitive_type_char32_t]
 963     = builtin->builtin_char32;
 964   lai->primitive_type_vector [cplus_primitive_type_wchar_t]
 965     = builtin->builtin_wchar;
 966
 967   lai->bool_type_symbol = "bool";
 968   lai->bool_type_default = builtin->builtin_bool;
 969 }
 970
 971 static const char *cplus_extensions[] =
 972 {
 973   ".C", ".cc", ".cp", ".cpp", ".cxx", ".c++", NULL
 974 };
 975
 976 extern const struct language_defn cplus_language_defn =
 977 {
 978   "c++",                        /* Language name */
 979   "C++",
 980   language_cplus,
 981   range_check_off,
 982   case_sensitive_on,
 983   array_row_major,
 984   macro_expansion_c,
 985   cplus_extensions,
 986   &exp_descriptor_c,
 987   c_parse,
 988   null_post_parser,
 989   c_printchar,                  /* Print a character constant */
 990   c_printstr,                   /* Function to print string constant */
 991   c_emit_char,                  /* Print a single char */
 992   c_print_type,                 /* Print a type using appropriate syntax */
 993   c_print_typedef,              /* Print a typedef using appropriate syntax */
 994   c_val_print,                  /* Print a value using appropriate syntax */
 995   c_value_print,                /* Print a top-level value */
 996   default_read_var_value,       /* la_read_var_value */
 997   cplus_skip_trampoline,        /* Language specific skip_trampoline */
 998   "this",                       /* name_of_this */
 999   false,                        /* la_store_sym_names_in_linkage_form_p */
1000   cp_lookup_symbol_nonlocal,    /* lookup_symbol_nonlocal */
1001   cp_lookup_transparent_type,   /* lookup_transparent_type */
1002   gdb_demangle,                 /* Language specific symbol demangler */
1003   gdb_sniff_from_mangled_name,
1004   cp_class_name_from_physname,  /* Language specific
1005                                    class_name_from_physname */
1006   c_op_print_tab,               /* expression operators for printing */
1007   1,                            /* c-style arrays */
1008   0,                            /* String lower bound */
1009   default_word_break_characters,
1010   default_collect_symbol_completion_matches,
1011   cplus_language_arch_info,
1012   default_print_array_index,
1013   cp_pass_by_reference,
1014   c_get_string,
1015   c_watch_location_expression,
1016   cp_get_symbol_name_matcher,
1017   iterate_over_symbols,
1018   cp_search_name_hash,
1019   &cplus_varobj_ops,
1020   cplus_get_compile_context,
1021   cplus_compute_program,
1022   LANG_MAGIC
1023 };
1024
1025 static const char *asm_extensions[] =
1026 {
1027   ".s", ".sx", ".S", NULL
1028 };
1029
1030 extern const struct language_defn asm_language_defn =
1031 {
1032   "asm",                        /* Language name */
1033   "assembly",
1034   language_asm,
1035   range_check_off,
1036   case_sensitive_on,
1037   array_row_major,
1038   macro_expansion_c,
1039   asm_extensions,
1040   &exp_descriptor_c,
1041   c_parse,
1042   null_post_parser,
1043   c_printchar,                  /* Print a character constant */
1044   c_printstr,                   /* Function to print string constant */
1045   c_emit_char,                  /* Print a single char */
1046   c_print_type,                 /* Print a type using appropriate syntax */
1047   c_print_typedef,              /* Print a typedef using appropriate syntax */
1048   c_val_print,                  /* Print a value using appropriate syntax */
1049   c_value_print,                /* Print a top-level value */
1050   default_read_var_value,       /* la_read_var_value */
1051   NULL,                         /* Language specific skip_trampoline */
1052   NULL,                         /* name_of_this */
1053   true,                         /* la_store_sym_names_in_linkage_form_p */
1054   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1055   basic_lookup_transparent_type,/* lookup_transparent_type */
1056   NULL,                         /* Language specific symbol demangler */
1057   NULL,
1058   NULL,                         /* Language specific
1059                                    class_name_from_physname */
1060   c_op_print_tab,               /* expression operators for printing */
1061   1,                            /* c-style arrays */
1062   0,                            /* String lower bound */
1063   default_word_break_characters,
1064   default_collect_symbol_completion_matches,
1065   c_language_arch_info,         /* FIXME: la_language_arch_info.  */
1066   default_print_array_index,
1067   default_pass_by_reference,
1068   c_get_string,
1069   c_watch_location_expression,
1070   NULL,                         /* la_get_symbol_name_matcher */
1071   iterate_over_symbols,
1072   default_search_name_hash,
1073   &default_varobj_ops,
1074   NULL,
1075   NULL,
1076   LANG_MAGIC
1077 };
1078
1079 /* The following language_defn does not represent a real language.
1080    It just provides a minimal support a-la-C that should allow users
1081    to do some simple operations when debugging applications that use
1082    a language currently not supported by GDB.  */
1083
1084 extern const struct language_defn minimal_language_defn =
1085 {
1086   "minimal",                    /* Language name */
1087   "Minimal",
1088   language_minimal,
1089   range_check_off,
1090   case_sensitive_on,
1091   array_row_major,
1092   macro_expansion_c,
1093   NULL,
1094   &exp_descriptor_c,
1095   c_parse,
1096   null_post_parser,
1097   c_printchar,                  /* Print a character constant */
1098   c_printstr,                   /* Function to print string constant */
1099   c_emit_char,                  /* Print a single char */
1100   c_print_type,                 /* Print a type using appropriate syntax */
1101   c_print_typedef,              /* Print a typedef using appropriate syntax */
1102   c_val_print,                  /* Print a value using appropriate syntax */
1103   c_value_print,                /* Print a top-level value */
1104   default_read_var_value,       /* la_read_var_value */
1105   NULL,                         /* Language specific skip_trampoline */
1106   NULL,                         /* name_of_this */
1107   true,                         /* la_store_sym_names_in_linkage_form_p */
1108   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1109   basic_lookup_transparent_type,/* lookup_transparent_type */
1110   NULL,                         /* Language specific symbol demangler */
1111   NULL,
1112   NULL,                         /* Language specific
1113                                    class_name_from_physname */
1114   c_op_print_tab,               /* expression operators for printing */
1115   1,                            /* c-style arrays */
1116   0,                            /* String lower bound */
1117   default_word_break_characters,
1118   default_collect_symbol_completion_matches,
1119   c_language_arch_info,
1120   default_print_array_index,
1121   default_pass_by_reference,
1122   c_get_string,
1123   c_watch_location_expression,
1124   NULL,                         /* la_get_symbol_name_matcher */
1125   iterate_over_symbols,
1126   default_search_name_hash,
1127   &default_varobj_ops,
1128   NULL,
1129   NULL,
1130   LANG_MAGIC
1131 };