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
 284      An array is assumed to live in GDB's memory, so we take this path
 285      here.
 286
 287      However, it's possible for the caller to request more array
 288      elements than apparently exist -- this can happen when using the
 289      C struct hack.  So, only do this if either no length was
 290      specified, or the length is within the existing bounds.  This
 291      avoids running off the end of the value's contents.  */
 292   if ((VALUE_LVAL (value) == not_lval
 293        || VALUE_LVAL (value) == lval_internalvar
 294        || TYPE_CODE (type) == TYPE_CODE_ARRAY)
 295       && fetchlimit != UINT_MAX
 296       && (*length < 0 || *length <= fetchlimit))
 297     {
 298       int i;
 299       const gdb_byte *contents = value_contents (value);
 300
 301       /* If a length is specified, use that.  */
 302       if (*length >= 0)
 303         i  = *length;
 304       else
 305         /* Otherwise, look for a null character.  */
 306         for (i = 0; i < fetchlimit; i++)
 307           if (extract_unsigned_integer (contents + i * width,
 308                                         width, byte_order) == 0)
 309             break;
 310
 311       /* I is now either a user-defined length, the number of non-null
 312          characters, or FETCHLIMIT.  */
 313       *length = i * width;
 314       buffer->reset ((gdb_byte *) xmalloc (*length));
 315       memcpy (buffer->get (), contents, *length);
 316       err = 0;
 317     }
 318   else
 319     {
 320       /* value_as_address does not return an address for an array when
 321          c_style_arrays is false, so we handle that specially
 322          here.  */
 323       CORE_ADDR addr;
 324       if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
 325         {
 326           if (VALUE_LVAL (value) != lval_memory)
 327             error (_("Attempt to take address of value "
 328                      "not located in memory."));
 329           addr = value_address (value);
 330         }
 331       else
 332         addr = value_as_address (value);
 333
 334       /* Prior to the fix for PR 16196 read_string would ignore fetchlimit
 335          if length > 0.  The old "broken" behaviour is the behaviour we want:
 336          The caller may want to fetch 100 bytes from a variable length array
 337          implemented using the common idiom of having an array of length 1 at
 338          the end of a struct.  In this case we want to ignore the declared
 339          size of the array.  However, it's counterintuitive to implement that
 340          behaviour in read_string: what does fetchlimit otherwise mean if
 341          length > 0.  Therefore we implement the behaviour we want here:
 342          If *length > 0, don't specify a fetchlimit.  This preserves the
 343          previous behaviour.  We could move this check above where we know
 344          whether the array is declared with a fixed size, but we only want
 345          to apply this behaviour when calling read_string.  PR 16286.  */
 346       if (*length > 0)
 347         fetchlimit = UINT_MAX;
 348
 349       err = read_string (addr, *length, width, fetchlimit,
 350                          byte_order, buffer, length);
 351       if (err != 0)
 352         memory_error (TARGET_XFER_E_IO, addr);
 353     }
 354
 355   /* If the LENGTH is specified at -1, we want to return the string
 356      length up to the terminating null character.  If an actual length
 357      was specified, we want to return the length of exactly what was
 358      read.  */
 359   if (req_length == -1)
 360     /* If the last character is null, subtract it from LENGTH.  */
 361     if (*length > 0
 362         && extract_unsigned_integer (buffer->get () + *length - width,
 363                                      width, byte_order) == 0)
 364       *length -= width;
 365
 366   /* The read_string function will return the number of bytes read.
 367      If length returned from read_string was > 0, return the number of
 368      characters read by dividing the number of bytes by width.  */
 369   if (*length != 0)
 370      *length = *length / width;
 371
 372   *char_type = element_type;
 373
 374   return;
 375
 376  error:
 377   {
 378     std::string type_str = type_to_string (type);
 379     if (!type_str.empty ())
 380       {
 381         error (_("Trying to read string with inappropriate type `%s'."),
 382                type_str.c_str ());
 383       }
 384     else
 385       error (_("Trying to read string with inappropriate type."));
 386   }
 387 }
 388
 389 \f
 390 /* Evaluating C and C++ expressions.  */
 391
 392 /* Convert a UCN.  The digits of the UCN start at P and extend no
 393    farther than LIMIT.  DEST_CHARSET is the name of the character set
 394    into which the UCN should be converted.  The results are written to
 395    OUTPUT.  LENGTH is the maximum length of the UCN, either 4 or 8.
 396    Returns a pointer to just after the final digit of the UCN.  */
 397
 398 static char *
 399 convert_ucn (char *p, char *limit, const char *dest_charset,
 400              struct obstack *output, int length)
 401 {
 402   unsigned long result = 0;
 403   gdb_byte data[4];
 404   int i;
 405
 406   for (i = 0; i < length && p < limit && ISXDIGIT (*p); ++i, ++p)
 407     result = (result << 4) + host_hex_value (*p);
 408
 409   for (i = 3; i >= 0; --i)
 410     {
 411       data[i] = result & 0xff;
 412       result >>= 8;
 413     }
 414
 415   convert_between_encodings ("UTF-32BE", dest_charset, data,
 416                              4, 4, output, translit_none);
 417
 418   return p;
 419 }
 420
 421 /* Emit a character, VALUE, which was specified numerically, to
 422    OUTPUT.  TYPE is the target character type.  */
 423
 424 static void
 425 emit_numeric_character (struct type *type, unsigned long value,
 426                         struct obstack *output)
 427 {
 428   gdb_byte *buffer;
 429
 430   buffer = (gdb_byte *) alloca (TYPE_LENGTH (type));
 431   pack_long (buffer, type, value);
 432   obstack_grow (output, buffer, TYPE_LENGTH (type));
 433 }
 434
 435 /* Convert an octal escape sequence.  TYPE is the target character
 436    type.  The digits of the escape sequence begin at P and extend no
 437    farther than LIMIT.  The result is written to OUTPUT.  Returns a
 438    pointer to just after the final digit of the escape sequence.  */
 439
 440 static char *
 441 convert_octal (struct type *type, char *p,
 442                char *limit, struct obstack *output)
 443 {
 444   int i;
 445   unsigned long value = 0;
 446
 447   for (i = 0;
 448        i < 3 && p < limit && ISDIGIT (*p) && *p != '8' && *p != '9';
 449        ++i)
 450     {
 451       value = 8 * value + host_hex_value (*p);
 452       ++p;
 453     }
 454
 455   emit_numeric_character (type, value, output);
 456
 457   return p;
 458 }
 459
 460 /* Convert a hex escape sequence.  TYPE is the target character type.
 461    The digits of the escape sequence begin at P and extend no farther
 462    than LIMIT.  The result is written to OUTPUT.  Returns a pointer to
 463    just after the final digit of the escape sequence.  */
 464
 465 static char *
 466 convert_hex (struct type *type, char *p,
 467              char *limit, struct obstack *output)
 468 {
 469   unsigned long value = 0;
 470
 471   while (p < limit && ISXDIGIT (*p))
 472     {
 473       value = 16 * value + host_hex_value (*p);
 474       ++p;
 475     }
 476
 477   emit_numeric_character (type, value, output);
 478
 479   return p;
 480 }
 481
 482 #define ADVANCE                                 \
 483   do {                                          \
 484     ++p;                                        \
 485     if (p == limit)                             \
 486       error (_("Malformed escape sequence"));   \
 487   } while (0)
 488
 489 /* Convert an escape sequence to a target format.  TYPE is the target
 490    character type to use, and DEST_CHARSET is the name of the target
 491    character set.  The backslash of the escape sequence is at *P, and
 492    the escape sequence will not extend past LIMIT.  The results are
 493    written to OUTPUT.  Returns a pointer to just past the final
 494    character of the escape sequence.  */
 495
 496 static char *
 497 convert_escape (struct type *type, const char *dest_charset,
 498                 char *p, char *limit, struct obstack *output)
 499 {
 500   /* Skip the backslash.  */
 501   ADVANCE;
 502
 503   switch (*p)
 504     {
 505     case '\\':
 506       obstack_1grow (output, '\\');
 507       ++p;
 508       break;
 509
 510     case 'x':
 511       ADVANCE;
 512       if (!ISXDIGIT (*p))
 513         error (_("\\x used with no following hex digits."));
 514       p = convert_hex (type, p, limit, output);
 515       break;
 516
 517     case '0':
 518     case '1':
 519     case '2':
 520     case '3':
 521     case '4':
 522     case '5':
 523     case '6':
 524     case '7':
 525       p = convert_octal (type, p, limit, output);
 526       break;
 527
 528     case 'u':
 529     case 'U':
 530       {
 531         int length = *p == 'u' ? 4 : 8;
 532
 533         ADVANCE;
 534         if (!ISXDIGIT (*p))
 535           error (_("\\u used with no following hex digits"));
 536         p = convert_ucn (p, limit, dest_charset, output, length);
 537       }
 538     }
 539
 540   return p;
 541 }
 542
 543 /* Given a single string from a (C-specific) OP_STRING list, convert
 544    it to a target string, handling escape sequences specially.  The
 545    output is written to OUTPUT.  DATA is the input string, which has
 546    length LEN.  DEST_CHARSET is the name of the target character set,
 547    and TYPE is the type of target character to use.  */
 548
 549 static void
 550 parse_one_string (struct obstack *output, char *data, int len,
 551                   const char *dest_charset, struct type *type)
 552 {
 553   char *limit;
 554
 555   limit = data + len;
 556
 557   while (data < limit)
 558     {
 559       char *p = data;
 560
 561       /* Look for next escape, or the end of the input.  */
 562       while (p < limit && *p != '\\')
 563         ++p;
 564       /* If we saw a run of characters, convert them all.  */
 565       if (p > data)
 566         convert_between_encodings (host_charset (), dest_charset,
 567                                    (gdb_byte *) data, p - data, 1,
 568                                    output, translit_none);
 569       /* If we saw an escape, convert it.  */
 570       if (p < limit)
 571         p = convert_escape (type, dest_charset, p, limit, output);
 572       data = p;
 573     }
 574 }
 575
 576 /* Expression evaluator for the C language family.  Most operations
 577    are delegated to evaluate_subexp_standard; see that function for a
 578    description of the arguments.  */
 579
 580 struct value *
 581 evaluate_subexp_c (struct type *expect_type, struct expression *exp,
 582                    int *pos, enum noside noside)
 583 {
 584   enum exp_opcode op = exp->elts[*pos].opcode;
 585
 586   switch (op)
 587     {
 588     case OP_STRING:
 589       {
 590         int oplen, limit;
 591         struct type *type;
 592         struct value *result;
 593         c_string_type dest_type;
 594         const char *dest_charset;
 595         int satisfy_expected = 0;
 596
 597         auto_obstack output;
 598
 599         ++*pos;
 600         oplen = longest_to_int (exp->elts[*pos].longconst);
 601
 602         ++*pos;
 603         limit = *pos + BYTES_TO_EXP_ELEM (oplen + 1);
 604         dest_type = ((enum c_string_type_values)
 605                      longest_to_int (exp->elts[*pos].longconst));
 606         switch (dest_type & ~C_CHAR)
 607           {
 608           case C_STRING:
 609             type = language_string_char_type (exp->language_defn,
 610                                               exp->gdbarch);
 611             break;
 612           case C_WIDE_STRING:
 613             type = lookup_typename (exp->language_defn, exp->gdbarch,
 614                                     "wchar_t", NULL, 0);
 615             break;
 616           case C_STRING_16:
 617             type = lookup_typename (exp->language_defn, exp->gdbarch,
 618                                     "char16_t", NULL, 0);
 619             break;
 620           case C_STRING_32:
 621             type = lookup_typename (exp->language_defn, exp->gdbarch,
 622                                     "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 && TYPE_CODE (expect_type) == TYPE_CODE_ARRAY)
 635           {
 636             struct type *element_type
 637               = check_typedef (TYPE_TARGET_TYPE (expect_type));
 638
 639             if (TYPE_CODE (element_type) == TYPE_CODE_INT
 640                 || TYPE_CODE (element_type) == 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 (TYPE_INDEX_TYPE (expect_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 /* la_watch_location_expression for C.  */
 731
 732 gdb::unique_xmalloc_ptr<char>
 733 c_watch_location_expression (struct type *type, CORE_ADDR addr)
 734 {
 735   type = check_typedef (TYPE_TARGET_TYPE (check_typedef (type)));
 736   std::string name = type_to_string (type);
 737   return gdb::unique_xmalloc_ptr<char>
 738     (xstrprintf ("* (%s *) %s", name.c_str (), core_addr_to_string (addr)));
 739 }
 740
 741 /* See c-lang.h.  */
 742
 743 bool
 744 c_is_string_type_p (struct type *type)
 745 {
 746   type = check_typedef (type);
 747   while (TYPE_CODE (type) == TYPE_CODE_REF)
 748     {
 749       type = TYPE_TARGET_TYPE (type);
 750       type = check_typedef (type);
 751     }
 752
 753   switch (TYPE_CODE (type))
 754     {
 755     case TYPE_CODE_ARRAY:
 756       {
 757         /* See if target type looks like a string.  */
 758         struct type *array_target_type = TYPE_TARGET_TYPE (type);
 759         return (TYPE_LENGTH (type) > 0
 760                 && TYPE_LENGTH (array_target_type) > 0
 761                 && c_textual_element_type (array_target_type, 0));
 762       }
 763     case TYPE_CODE_STRING:
 764       return true;
 765     case TYPE_CODE_PTR:
 766       {
 767         struct type *element_type = TYPE_TARGET_TYPE (type);
 768         return c_textual_element_type (element_type, 0);
 769       }
 770     default:
 771       break;
 772     }
 773
 774   return false;
 775 }
 776
 777 \f
 778 /* Table mapping opcodes into strings for printing operators
 779    and precedences of the operators.  */
 780
 781 const struct op_print c_op_print_tab[] =
 782 {
 783   {",", BINOP_COMMA, PREC_COMMA, 0},
 784   {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
 785   {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
 786   {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
 787   {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
 788   {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
 789   {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
 790   {"==", BINOP_EQUAL, PREC_EQUAL, 0},
 791   {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
 792   {"<=", BINOP_LEQ, PREC_ORDER, 0},
 793   {">=", BINOP_GEQ, PREC_ORDER, 0},
 794   {">", BINOP_GTR, PREC_ORDER, 0},
 795   {"<", BINOP_LESS, PREC_ORDER, 0},
 796   {">>", BINOP_RSH, PREC_SHIFT, 0},
 797   {"<<", BINOP_LSH, PREC_SHIFT, 0},
 798   {"+", BINOP_ADD, PREC_ADD, 0},
 799   {"-", BINOP_SUB, PREC_ADD, 0},
 800   {"*", BINOP_MUL, PREC_MUL, 0},
 801   {"/", BINOP_DIV, PREC_MUL, 0},
 802   {"%", BINOP_REM, PREC_MUL, 0},
 803   {"@", BINOP_REPEAT, PREC_REPEAT, 0},
 804   {"+", UNOP_PLUS, PREC_PREFIX, 0},
 805   {"-", UNOP_NEG, PREC_PREFIX, 0},
 806   {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
 807   {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
 808   {"*", UNOP_IND, PREC_PREFIX, 0},
 809   {"&", UNOP_ADDR, PREC_PREFIX, 0},
 810   {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
 811   {"alignof ", UNOP_ALIGNOF, PREC_PREFIX, 0},
 812   {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
 813   {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
 814   {NULL, OP_NULL, PREC_PREFIX, 0}
 815 };
 816 \f
 817 enum c_primitive_types {
 818   c_primitive_type_int,
 819   c_primitive_type_long,
 820   c_primitive_type_short,
 821   c_primitive_type_char,
 822   c_primitive_type_float,
 823   c_primitive_type_double,
 824   c_primitive_type_void,
 825   c_primitive_type_long_long,
 826   c_primitive_type_signed_char,
 827   c_primitive_type_unsigned_char,
 828   c_primitive_type_unsigned_short,
 829   c_primitive_type_unsigned_int,
 830   c_primitive_type_unsigned_long,
 831   c_primitive_type_unsigned_long_long,
 832   c_primitive_type_long_double,
 833   c_primitive_type_complex,
 834   c_primitive_type_double_complex,
 835   c_primitive_type_decfloat,
 836   c_primitive_type_decdouble,
 837   c_primitive_type_declong,
 838   nr_c_primitive_types
 839 };
 840
 841 void
 842 c_language_arch_info (struct gdbarch *gdbarch,
 843                       struct language_arch_info *lai)
 844 {
 845   const struct builtin_type *builtin = builtin_type (gdbarch);
 846
 847   lai->string_char_type = builtin->builtin_char;
 848   lai->primitive_type_vector
 849     = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_c_primitive_types + 1,
 850                               struct type *);
 851   lai->primitive_type_vector [c_primitive_type_int] = builtin->builtin_int;
 852   lai->primitive_type_vector [c_primitive_type_long] = builtin->builtin_long;
 853   lai->primitive_type_vector [c_primitive_type_short] = builtin->builtin_short;
 854   lai->primitive_type_vector [c_primitive_type_char] = builtin->builtin_char;
 855   lai->primitive_type_vector [c_primitive_type_float] = builtin->builtin_float;
 856   lai->primitive_type_vector [c_primitive_type_double] = builtin->builtin_double;
 857   lai->primitive_type_vector [c_primitive_type_void] = builtin->builtin_void;
 858   lai->primitive_type_vector [c_primitive_type_long_long] = builtin->builtin_long_long;
 859   lai->primitive_type_vector [c_primitive_type_signed_char] = builtin->builtin_signed_char;
 860   lai->primitive_type_vector [c_primitive_type_unsigned_char] = builtin->builtin_unsigned_char;
 861   lai->primitive_type_vector [c_primitive_type_unsigned_short] = builtin->builtin_unsigned_short;
 862   lai->primitive_type_vector [c_primitive_type_unsigned_int] = builtin->builtin_unsigned_int;
 863   lai->primitive_type_vector [c_primitive_type_unsigned_long] = builtin->builtin_unsigned_long;
 864   lai->primitive_type_vector [c_primitive_type_unsigned_long_long] = builtin->builtin_unsigned_long_long;
 865   lai->primitive_type_vector [c_primitive_type_long_double] = builtin->builtin_long_double;
 866   lai->primitive_type_vector [c_primitive_type_complex] = builtin->builtin_complex;
 867   lai->primitive_type_vector [c_primitive_type_double_complex] = builtin->builtin_double_complex;
 868   lai->primitive_type_vector [c_primitive_type_decfloat] = builtin->builtin_decfloat;
 869   lai->primitive_type_vector [c_primitive_type_decdouble] = builtin->builtin_decdouble;
 870   lai->primitive_type_vector [c_primitive_type_declong] = builtin->builtin_declong;
 871
 872   lai->bool_type_default = builtin->builtin_int;
 873 }
 874
 875 const struct exp_descriptor exp_descriptor_c =
 876 {
 877   print_subexp_standard,
 878   operator_length_standard,
 879   operator_check_standard,
 880   op_name_standard,
 881   dump_subexp_body_standard,
 882   evaluate_subexp_c
 883 };
 884
 885 static const char *c_extensions[] =
 886 {
 887   ".c", NULL
 888 };
 889
 890 extern const struct language_defn c_language_defn =
 891 {
 892   "c",                          /* Language name */
 893   "C",
 894   language_c,
 895   range_check_off,
 896   case_sensitive_on,
 897   array_row_major,
 898   macro_expansion_c,
 899   c_extensions,
 900   &exp_descriptor_c,
 901   c_parse,
 902   null_post_parser,
 903   c_printchar,                  /* Print a character constant */
 904   c_printstr,                   /* Function to print string constant */
 905   c_emit_char,                  /* Print a single char */
 906   c_print_type,                 /* Print a type using appropriate syntax */
 907   c_print_typedef,              /* Print a typedef using appropriate syntax */
 908   c_val_print,                  /* Print a value using appropriate syntax */
 909   c_value_print,                /* Print a top-level value */
 910   default_read_var_value,       /* la_read_var_value */
 911   NULL,                         /* Language specific skip_trampoline */
 912   NULL,                         /* name_of_this */
 913   true,                         /* la_store_sym_names_in_linkage_form_p */
 914   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
 915   basic_lookup_transparent_type,/* lookup_transparent_type */
 916   NULL,                         /* Language specific symbol demangler */
 917   NULL,
 918   NULL,                         /* Language specific
 919                                    class_name_from_physname */
 920   c_op_print_tab,               /* expression operators for printing */
 921   1,                            /* c-style arrays */
 922   0,                            /* String lower bound */
 923   default_word_break_characters,
 924   default_collect_symbol_completion_matches,
 925   c_language_arch_info,
 926   default_print_array_index,
 927   default_pass_by_reference,
 928   c_get_string,
 929   c_watch_location_expression,
 930   NULL,                         /* la_get_symbol_name_matcher */
 931   iterate_over_symbols,
 932   default_search_name_hash,
 933   &c_varobj_ops,
 934   c_get_compile_context,
 935   c_compute_program,
 936   c_is_string_type_p,
 937   "{...}"                       /* la_struct_too_deep_ellipsis */
 938 };
 939
 940 enum cplus_primitive_types {
 941   cplus_primitive_type_int,
 942   cplus_primitive_type_long,
 943   cplus_primitive_type_short,
 944   cplus_primitive_type_char,
 945   cplus_primitive_type_float,
 946   cplus_primitive_type_double,
 947   cplus_primitive_type_void,
 948   cplus_primitive_type_long_long,
 949   cplus_primitive_type_signed_char,
 950   cplus_primitive_type_unsigned_char,
 951   cplus_primitive_type_unsigned_short,
 952   cplus_primitive_type_unsigned_int,
 953   cplus_primitive_type_unsigned_long,
 954   cplus_primitive_type_unsigned_long_long,
 955   cplus_primitive_type_long_double,
 956   cplus_primitive_type_complex,
 957   cplus_primitive_type_double_complex,
 958   cplus_primitive_type_bool,
 959   cplus_primitive_type_decfloat,
 960   cplus_primitive_type_decdouble,
 961   cplus_primitive_type_declong,
 962   cplus_primitive_type_char16_t,
 963   cplus_primitive_type_char32_t,
 964   cplus_primitive_type_wchar_t,
 965   nr_cplus_primitive_types
 966 };
 967
 968 static void
 969 cplus_language_arch_info (struct gdbarch *gdbarch,
 970                           struct language_arch_info *lai)
 971 {
 972   const struct builtin_type *builtin = builtin_type (gdbarch);
 973
 974   lai->string_char_type = builtin->builtin_char;
 975   lai->primitive_type_vector
 976     = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_cplus_primitive_types + 1,
 977                               struct type *);
 978   lai->primitive_type_vector [cplus_primitive_type_int]
 979     = builtin->builtin_int;
 980   lai->primitive_type_vector [cplus_primitive_type_long]
 981     = builtin->builtin_long;
 982   lai->primitive_type_vector [cplus_primitive_type_short]
 983     = builtin->builtin_short;
 984   lai->primitive_type_vector [cplus_primitive_type_char]
 985     = builtin->builtin_char;
 986   lai->primitive_type_vector [cplus_primitive_type_float]
 987     = builtin->builtin_float;
 988   lai->primitive_type_vector [cplus_primitive_type_double]
 989     = builtin->builtin_double;
 990   lai->primitive_type_vector [cplus_primitive_type_void]
 991     = builtin->builtin_void;
 992   lai->primitive_type_vector [cplus_primitive_type_long_long]
 993     = builtin->builtin_long_long;
 994   lai->primitive_type_vector [cplus_primitive_type_signed_char]
 995     = builtin->builtin_signed_char;
 996   lai->primitive_type_vector [cplus_primitive_type_unsigned_char]
 997     = builtin->builtin_unsigned_char;
 998   lai->primitive_type_vector [cplus_primitive_type_unsigned_short]
 999     = builtin->builtin_unsigned_short;
1000   lai->primitive_type_vector [cplus_primitive_type_unsigned_int]
1001     = builtin->builtin_unsigned_int;
1002   lai->primitive_type_vector [cplus_primitive_type_unsigned_long]
1003     = builtin->builtin_unsigned_long;
1004   lai->primitive_type_vector [cplus_primitive_type_unsigned_long_long]
1005     = builtin->builtin_unsigned_long_long;
1006   lai->primitive_type_vector [cplus_primitive_type_long_double]
1007     = builtin->builtin_long_double;
1008   lai->primitive_type_vector [cplus_primitive_type_complex]
1009     = builtin->builtin_complex;
1010   lai->primitive_type_vector [cplus_primitive_type_double_complex]
1011     = builtin->builtin_double_complex;
1012   lai->primitive_type_vector [cplus_primitive_type_bool]
1013     = builtin->builtin_bool;
1014   lai->primitive_type_vector [cplus_primitive_type_decfloat]
1015     = builtin->builtin_decfloat;
1016   lai->primitive_type_vector [cplus_primitive_type_decdouble]
1017     = builtin->builtin_decdouble;
1018   lai->primitive_type_vector [cplus_primitive_type_declong]
1019     = builtin->builtin_declong;
1020   lai->primitive_type_vector [cplus_primitive_type_char16_t]
1021     = builtin->builtin_char16;
1022   lai->primitive_type_vector [cplus_primitive_type_char32_t]
1023     = builtin->builtin_char32;
1024   lai->primitive_type_vector [cplus_primitive_type_wchar_t]
1025     = builtin->builtin_wchar;
1026
1027   lai->bool_type_symbol = "bool";
1028   lai->bool_type_default = builtin->builtin_bool;
1029 }
1030
1031 static const char *cplus_extensions[] =
1032 {
1033   ".C", ".cc", ".cp", ".cpp", ".cxx", ".c++", NULL
1034 };
1035
1036 extern const struct language_defn cplus_language_defn =
1037 {
1038   "c++",                        /* Language name */
1039   "C++",
1040   language_cplus,
1041   range_check_off,
1042   case_sensitive_on,
1043   array_row_major,
1044   macro_expansion_c,
1045   cplus_extensions,
1046   &exp_descriptor_c,
1047   c_parse,
1048   null_post_parser,
1049   c_printchar,                  /* Print a character constant */
1050   c_printstr,                   /* Function to print string constant */
1051   c_emit_char,                  /* Print a single char */
1052   c_print_type,                 /* Print a type using appropriate syntax */
1053   c_print_typedef,              /* Print a typedef using appropriate syntax */
1054   c_val_print,                  /* Print a value using appropriate syntax */
1055   c_value_print,                /* Print a top-level value */
1056   default_read_var_value,       /* la_read_var_value */
1057   cplus_skip_trampoline,        /* Language specific skip_trampoline */
1058   "this",                       /* name_of_this */
1059   false,                        /* la_store_sym_names_in_linkage_form_p */
1060   cp_lookup_symbol_nonlocal,    /* lookup_symbol_nonlocal */
1061   cp_lookup_transparent_type,   /* lookup_transparent_type */
1062   gdb_demangle,                 /* Language specific symbol demangler */
1063   gdb_sniff_from_mangled_name,
1064   cp_class_name_from_physname,  /* Language specific
1065                                    class_name_from_physname */
1066   c_op_print_tab,               /* expression operators for printing */
1067   1,                            /* c-style arrays */
1068   0,                            /* String lower bound */
1069   default_word_break_characters,
1070   default_collect_symbol_completion_matches,
1071   cplus_language_arch_info,
1072   default_print_array_index,
1073   cp_pass_by_reference,
1074   c_get_string,
1075   c_watch_location_expression,
1076   cp_get_symbol_name_matcher,
1077   iterate_over_symbols,
1078   cp_search_name_hash,
1079   &cplus_varobj_ops,
1080   cplus_get_compile_context,
1081   cplus_compute_program,
1082   c_is_string_type_p,
1083   "{...}"                       /* la_struct_too_deep_ellipsis */
1084 };
1085
1086 static const char *asm_extensions[] =
1087 {
1088   ".s", ".sx", ".S", NULL
1089 };
1090
1091 extern const struct language_defn asm_language_defn =
1092 {
1093   "asm",                        /* Language name */
1094   "assembly",
1095   language_asm,
1096   range_check_off,
1097   case_sensitive_on,
1098   array_row_major,
1099   macro_expansion_c,
1100   asm_extensions,
1101   &exp_descriptor_c,
1102   c_parse,
1103   null_post_parser,
1104   c_printchar,                  /* Print a character constant */
1105   c_printstr,                   /* Function to print string constant */
1106   c_emit_char,                  /* Print a single char */
1107   c_print_type,                 /* Print a type using appropriate syntax */
1108   c_print_typedef,              /* Print a typedef using appropriate syntax */
1109   c_val_print,                  /* Print a value using appropriate syntax */
1110   c_value_print,                /* Print a top-level value */
1111   default_read_var_value,       /* la_read_var_value */
1112   NULL,                         /* Language specific skip_trampoline */
1113   NULL,                         /* name_of_this */
1114   true,                         /* la_store_sym_names_in_linkage_form_p */
1115   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1116   basic_lookup_transparent_type,/* lookup_transparent_type */
1117   NULL,                         /* Language specific symbol demangler */
1118   NULL,
1119   NULL,                         /* Language specific
1120                                    class_name_from_physname */
1121   c_op_print_tab,               /* expression operators for printing */
1122   1,                            /* c-style arrays */
1123   0,                            /* String lower bound */
1124   default_word_break_characters,
1125   default_collect_symbol_completion_matches,
1126   c_language_arch_info,         /* FIXME: la_language_arch_info.  */
1127   default_print_array_index,
1128   default_pass_by_reference,
1129   c_get_string,
1130   c_watch_location_expression,
1131   NULL,                         /* la_get_symbol_name_matcher */
1132   iterate_over_symbols,
1133   default_search_name_hash,
1134   &default_varobj_ops,
1135   NULL,
1136   NULL,
1137   c_is_string_type_p,
1138   "{...}"                       /* la_struct_too_deep_ellipsis */
1139 };
1140
1141 /* The following language_defn does not represent a real language.
1142    It just provides a minimal support a-la-C that should allow users
1143    to do some simple operations when debugging applications that use
1144    a language currently not supported by GDB.  */
1145
1146 extern const struct language_defn minimal_language_defn =
1147 {
1148   "minimal",                    /* Language name */
1149   "Minimal",
1150   language_minimal,
1151   range_check_off,
1152   case_sensitive_on,
1153   array_row_major,
1154   macro_expansion_c,
1155   NULL,
1156   &exp_descriptor_c,
1157   c_parse,
1158   null_post_parser,
1159   c_printchar,                  /* Print a character constant */
1160   c_printstr,                   /* Function to print string constant */
1161   c_emit_char,                  /* Print a single char */
1162   c_print_type,                 /* Print a type using appropriate syntax */
1163   c_print_typedef,              /* Print a typedef using appropriate syntax */
1164   c_val_print,                  /* Print a value using appropriate syntax */
1165   c_value_print,                /* Print a top-level value */
1166   default_read_var_value,       /* la_read_var_value */
1167   NULL,                         /* Language specific skip_trampoline */
1168   NULL,                         /* name_of_this */
1169   true,                         /* la_store_sym_names_in_linkage_form_p */
1170   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1171   basic_lookup_transparent_type,/* lookup_transparent_type */
1172   NULL,                         /* Language specific symbol demangler */
1173   NULL,
1174   NULL,                         /* Language specific
1175                                    class_name_from_physname */
1176   c_op_print_tab,               /* expression operators for printing */
1177   1,                            /* c-style arrays */
1178   0,                            /* String lower bound */
1179   default_word_break_characters,
1180   default_collect_symbol_completion_matches,
1181   c_language_arch_info,
1182   default_print_array_index,
1183   default_pass_by_reference,
1184   c_get_string,
1185   c_watch_location_expression,
1186   NULL,                         /* la_get_symbol_name_matcher */
1187   iterate_over_symbols,
1188   default_search_name_hash,
1189   &default_varobj_ops,
1190   NULL,
1191   NULL,
1192   c_is_string_type_p,
1193   "{...}"                       /* la_struct_too_deep_ellipsis */
1194 };