gdb/c-lang.c

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