gdb/c-lang.c

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