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   {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
 755   {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
 756   {NULL, OP_NULL, PREC_PREFIX, 0}
 757 };
 758 \f
 759 enum c_primitive_types {
 760   c_primitive_type_int,
 761   c_primitive_type_long,
 762   c_primitive_type_short,
 763   c_primitive_type_char,
 764   c_primitive_type_float,
 765   c_primitive_type_double,
 766   c_primitive_type_void,
 767   c_primitive_type_long_long,
 768   c_primitive_type_signed_char,
 769   c_primitive_type_unsigned_char,
 770   c_primitive_type_unsigned_short,
 771   c_primitive_type_unsigned_int,
 772   c_primitive_type_unsigned_long,
 773   c_primitive_type_unsigned_long_long,
 774   c_primitive_type_long_double,
 775   c_primitive_type_complex,
 776   c_primitive_type_double_complex,
 777   c_primitive_type_decfloat,
 778   c_primitive_type_decdouble,
 779   c_primitive_type_declong,
 780   nr_c_primitive_types
 781 };
 782
 783 void
 784 c_language_arch_info (struct gdbarch *gdbarch,
 785                       struct language_arch_info *lai)
 786 {
 787   const struct builtin_type *builtin = builtin_type (gdbarch);
 788
 789   lai->string_char_type = builtin->builtin_char;
 790   lai->primitive_type_vector
 791     = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_c_primitive_types + 1,
 792                               struct type *);
 793   lai->primitive_type_vector [c_primitive_type_int] = builtin->builtin_int;
 794   lai->primitive_type_vector [c_primitive_type_long] = builtin->builtin_long;
 795   lai->primitive_type_vector [c_primitive_type_short] = builtin->builtin_short;
 796   lai->primitive_type_vector [c_primitive_type_char] = builtin->builtin_char;
 797   lai->primitive_type_vector [c_primitive_type_float] = builtin->builtin_float;
 798   lai->primitive_type_vector [c_primitive_type_double] = builtin->builtin_double;
 799   lai->primitive_type_vector [c_primitive_type_void] = builtin->builtin_void;
 800   lai->primitive_type_vector [c_primitive_type_long_long] = builtin->builtin_long_long;
 801   lai->primitive_type_vector [c_primitive_type_signed_char] = builtin->builtin_signed_char;
 802   lai->primitive_type_vector [c_primitive_type_unsigned_char] = builtin->builtin_unsigned_char;
 803   lai->primitive_type_vector [c_primitive_type_unsigned_short] = builtin->builtin_unsigned_short;
 804   lai->primitive_type_vector [c_primitive_type_unsigned_int] = builtin->builtin_unsigned_int;
 805   lai->primitive_type_vector [c_primitive_type_unsigned_long] = builtin->builtin_unsigned_long;
 806   lai->primitive_type_vector [c_primitive_type_unsigned_long_long] = builtin->builtin_unsigned_long_long;
 807   lai->primitive_type_vector [c_primitive_type_long_double] = builtin->builtin_long_double;
 808   lai->primitive_type_vector [c_primitive_type_complex] = builtin->builtin_complex;
 809   lai->primitive_type_vector [c_primitive_type_double_complex] = builtin->builtin_double_complex;
 810   lai->primitive_type_vector [c_primitive_type_decfloat] = builtin->builtin_decfloat;
 811   lai->primitive_type_vector [c_primitive_type_decdouble] = builtin->builtin_decdouble;
 812   lai->primitive_type_vector [c_primitive_type_declong] = builtin->builtin_declong;
 813
 814   lai->bool_type_default = builtin->builtin_int;
 815 }
 816
 817 const struct exp_descriptor exp_descriptor_c =
 818 {
 819   print_subexp_standard,
 820   operator_length_standard,
 821   operator_check_standard,
 822   op_name_standard,
 823   dump_subexp_body_standard,
 824   evaluate_subexp_c
 825 };
 826
 827 static const char *c_extensions[] =
 828 {
 829   ".c", NULL
 830 };
 831
 832 extern const struct language_defn c_language_defn =
 833 {
 834   "c",                          /* Language name */
 835   "C",
 836   language_c,
 837   range_check_off,
 838   case_sensitive_on,
 839   array_row_major,
 840   macro_expansion_c,
 841   c_extensions,
 842   &exp_descriptor_c,
 843   c_parse,
 844   c_yyerror,
 845   null_post_parser,
 846   c_printchar,                  /* Print a character constant */
 847   c_printstr,                   /* Function to print string constant */
 848   c_emit_char,                  /* Print a single char */
 849   c_print_type,                 /* Print a type using appropriate syntax */
 850   c_print_typedef,              /* Print a typedef using appropriate syntax */
 851   c_val_print,                  /* Print a value using appropriate syntax */
 852   c_value_print,                /* Print a top-level value */
 853   default_read_var_value,       /* la_read_var_value */
 854   NULL,                         /* Language specific skip_trampoline */
 855   NULL,                         /* name_of_this */
 856   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
 857   basic_lookup_transparent_type,/* lookup_transparent_type */
 858   NULL,                         /* Language specific symbol demangler */
 859   NULL,
 860   NULL,                         /* Language specific
 861                                    class_name_from_physname */
 862   c_op_print_tab,               /* expression operators for printing */
 863   1,                            /* c-style arrays */
 864   0,                            /* String lower bound */
 865   default_word_break_characters,
 866   default_collect_symbol_completion_matches,
 867   c_language_arch_info,
 868   default_print_array_index,
 869   default_pass_by_reference,
 870   c_get_string,
 871   c_watch_location_expression,
 872   NULL,                         /* la_get_symbol_name_matcher */
 873   iterate_over_symbols,
 874   default_search_name_hash,
 875   &c_varobj_ops,
 876   c_get_compile_context,
 877   c_compute_program,
 878   LANG_MAGIC
 879 };
 880
 881 enum cplus_primitive_types {
 882   cplus_primitive_type_int,
 883   cplus_primitive_type_long,
 884   cplus_primitive_type_short,
 885   cplus_primitive_type_char,
 886   cplus_primitive_type_float,
 887   cplus_primitive_type_double,
 888   cplus_primitive_type_void,
 889   cplus_primitive_type_long_long,
 890   cplus_primitive_type_signed_char,
 891   cplus_primitive_type_unsigned_char,
 892   cplus_primitive_type_unsigned_short,
 893   cplus_primitive_type_unsigned_int,
 894   cplus_primitive_type_unsigned_long,
 895   cplus_primitive_type_unsigned_long_long,
 896   cplus_primitive_type_long_double,
 897   cplus_primitive_type_complex,
 898   cplus_primitive_type_double_complex,
 899   cplus_primitive_type_bool,
 900   cplus_primitive_type_decfloat,
 901   cplus_primitive_type_decdouble,
 902   cplus_primitive_type_declong,
 903   cplus_primitive_type_char16_t,
 904   cplus_primitive_type_char32_t,
 905   cplus_primitive_type_wchar_t,
 906   nr_cplus_primitive_types
 907 };
 908
 909 static void
 910 cplus_language_arch_info (struct gdbarch *gdbarch,
 911                           struct language_arch_info *lai)
 912 {
 913   const struct builtin_type *builtin = builtin_type (gdbarch);
 914
 915   lai->string_char_type = builtin->builtin_char;
 916   lai->primitive_type_vector
 917     = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_cplus_primitive_types + 1,
 918                               struct type *);
 919   lai->primitive_type_vector [cplus_primitive_type_int]
 920     = builtin->builtin_int;
 921   lai->primitive_type_vector [cplus_primitive_type_long]
 922     = builtin->builtin_long;
 923   lai->primitive_type_vector [cplus_primitive_type_short]
 924     = builtin->builtin_short;
 925   lai->primitive_type_vector [cplus_primitive_type_char]
 926     = builtin->builtin_char;
 927   lai->primitive_type_vector [cplus_primitive_type_float]
 928     = builtin->builtin_float;
 929   lai->primitive_type_vector [cplus_primitive_type_double]
 930     = builtin->builtin_double;
 931   lai->primitive_type_vector [cplus_primitive_type_void]
 932     = builtin->builtin_void;
 933   lai->primitive_type_vector [cplus_primitive_type_long_long]
 934     = builtin->builtin_long_long;
 935   lai->primitive_type_vector [cplus_primitive_type_signed_char]
 936     = builtin->builtin_signed_char;
 937   lai->primitive_type_vector [cplus_primitive_type_unsigned_char]
 938     = builtin->builtin_unsigned_char;
 939   lai->primitive_type_vector [cplus_primitive_type_unsigned_short]
 940     = builtin->builtin_unsigned_short;
 941   lai->primitive_type_vector [cplus_primitive_type_unsigned_int]
 942     = builtin->builtin_unsigned_int;
 943   lai->primitive_type_vector [cplus_primitive_type_unsigned_long]
 944     = builtin->builtin_unsigned_long;
 945   lai->primitive_type_vector [cplus_primitive_type_unsigned_long_long]
 946     = builtin->builtin_unsigned_long_long;
 947   lai->primitive_type_vector [cplus_primitive_type_long_double]
 948     = builtin->builtin_long_double;
 949   lai->primitive_type_vector [cplus_primitive_type_complex]
 950     = builtin->builtin_complex;
 951   lai->primitive_type_vector [cplus_primitive_type_double_complex]
 952     = builtin->builtin_double_complex;
 953   lai->primitive_type_vector [cplus_primitive_type_bool]
 954     = builtin->builtin_bool;
 955   lai->primitive_type_vector [cplus_primitive_type_decfloat]
 956     = builtin->builtin_decfloat;
 957   lai->primitive_type_vector [cplus_primitive_type_decdouble]
 958     = builtin->builtin_decdouble;
 959   lai->primitive_type_vector [cplus_primitive_type_declong]
 960     = builtin->builtin_declong;
 961   lai->primitive_type_vector [cplus_primitive_type_char16_t]
 962     = builtin->builtin_char16;
 963   lai->primitive_type_vector [cplus_primitive_type_char32_t]
 964     = builtin->builtin_char32;
 965   lai->primitive_type_vector [cplus_primitive_type_wchar_t]
 966     = builtin->builtin_wchar;
 967
 968   lai->bool_type_symbol = "bool";
 969   lai->bool_type_default = builtin->builtin_bool;
 970 }
 971
 972 static const char *cplus_extensions[] =
 973 {
 974   ".C", ".cc", ".cp", ".cpp", ".cxx", ".c++", NULL
 975 };
 976
 977 extern const struct language_defn cplus_language_defn =
 978 {
 979   "c++",                        /* Language name */
 980   "C++",
 981   language_cplus,
 982   range_check_off,
 983   case_sensitive_on,
 984   array_row_major,
 985   macro_expansion_c,
 986   cplus_extensions,
 987   &exp_descriptor_c,
 988   c_parse,
 989   c_yyerror,
 990   null_post_parser,
 991   c_printchar,                  /* Print a character constant */
 992   c_printstr,                   /* Function to print string constant */
 993   c_emit_char,                  /* Print a single char */
 994   c_print_type,                 /* Print a type using appropriate syntax */
 995   c_print_typedef,              /* Print a typedef using appropriate syntax */
 996   c_val_print,                  /* Print a value using appropriate syntax */
 997   c_value_print,                /* Print a top-level value */
 998   default_read_var_value,       /* la_read_var_value */
 999   cplus_skip_trampoline,        /* Language specific skip_trampoline */
1000   "this",                       /* name_of_this */
1001   cp_lookup_symbol_nonlocal,    /* lookup_symbol_nonlocal */
1002   cp_lookup_transparent_type,   /* lookup_transparent_type */
1003   gdb_demangle,                 /* Language specific symbol demangler */
1004   gdb_sniff_from_mangled_name,
1005   cp_class_name_from_physname,  /* Language specific
1006                                    class_name_from_physname */
1007   c_op_print_tab,               /* expression operators for printing */
1008   1,                            /* c-style arrays */
1009   0,                            /* String lower bound */
1010   default_word_break_characters,
1011   default_collect_symbol_completion_matches,
1012   cplus_language_arch_info,
1013   default_print_array_index,
1014   cp_pass_by_reference,
1015   c_get_string,
1016   c_watch_location_expression,
1017   cp_get_symbol_name_matcher,
1018   iterate_over_symbols,
1019   cp_search_name_hash,
1020   &cplus_varobj_ops,
1021   NULL,
1022   NULL,
1023   LANG_MAGIC
1024 };
1025
1026 static const char *asm_extensions[] =
1027 {
1028   ".s", ".sx", ".S", NULL
1029 };
1030
1031 extern const struct language_defn asm_language_defn =
1032 {
1033   "asm",                        /* Language name */
1034   "assembly",
1035   language_asm,
1036   range_check_off,
1037   case_sensitive_on,
1038   array_row_major,
1039   macro_expansion_c,
1040   asm_extensions,
1041   &exp_descriptor_c,
1042   c_parse,
1043   c_yyerror,
1044   null_post_parser,
1045   c_printchar,                  /* Print a character constant */
1046   c_printstr,                   /* Function to print string constant */
1047   c_emit_char,                  /* Print a single char */
1048   c_print_type,                 /* Print a type using appropriate syntax */
1049   c_print_typedef,              /* Print a typedef using appropriate syntax */
1050   c_val_print,                  /* Print a value using appropriate syntax */
1051   c_value_print,                /* Print a top-level value */
1052   default_read_var_value,       /* la_read_var_value */
1053   NULL,                         /* Language specific skip_trampoline */
1054   NULL,                         /* name_of_this */
1055   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1056   basic_lookup_transparent_type,/* lookup_transparent_type */
1057   NULL,                         /* Language specific symbol demangler */
1058   NULL,
1059   NULL,                         /* Language specific
1060                                    class_name_from_physname */
1061   c_op_print_tab,               /* expression operators for printing */
1062   1,                            /* c-style arrays */
1063   0,                            /* String lower bound */
1064   default_word_break_characters,
1065   default_collect_symbol_completion_matches,
1066   c_language_arch_info,         /* FIXME: la_language_arch_info.  */
1067   default_print_array_index,
1068   default_pass_by_reference,
1069   c_get_string,
1070   c_watch_location_expression,
1071   NULL,                         /* la_get_symbol_name_matcher */
1072   iterate_over_symbols,
1073   default_search_name_hash,
1074   &default_varobj_ops,
1075   NULL,
1076   NULL,
1077   LANG_MAGIC
1078 };
1079
1080 /* The following language_defn does not represent a real language.
1081    It just provides a minimal support a-la-C that should allow users
1082    to do some simple operations when debugging applications that use
1083    a language currently not supported by GDB.  */
1084
1085 extern const struct language_defn minimal_language_defn =
1086 {
1087   "minimal",                    /* Language name */
1088   "Minimal",
1089   language_minimal,
1090   range_check_off,
1091   case_sensitive_on,
1092   array_row_major,
1093   macro_expansion_c,
1094   NULL,
1095   &exp_descriptor_c,
1096   c_parse,
1097   c_yyerror,
1098   null_post_parser,
1099   c_printchar,                  /* Print a character constant */
1100   c_printstr,                   /* Function to print string constant */
1101   c_emit_char,                  /* Print a single char */
1102   c_print_type,                 /* Print a type using appropriate syntax */
1103   c_print_typedef,              /* Print a typedef using appropriate syntax */
1104   c_val_print,                  /* Print a value using appropriate syntax */
1105   c_value_print,                /* Print a top-level value */
1106   default_read_var_value,       /* la_read_var_value */
1107   NULL,                         /* Language specific skip_trampoline */
1108   NULL,                         /* name_of_this */
1109   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1110   basic_lookup_transparent_type,/* lookup_transparent_type */
1111   NULL,                         /* Language specific symbol demangler */
1112   NULL,
1113   NULL,                         /* Language specific
1114                                    class_name_from_physname */
1115   c_op_print_tab,               /* expression operators for printing */
1116   1,                            /* c-style arrays */
1117   0,                            /* String lower bound */
1118   default_word_break_characters,
1119   default_collect_symbol_completion_matches,
1120   c_language_arch_info,
1121   default_print_array_index,
1122   default_pass_by_reference,
1123   c_get_string,
1124   c_watch_location_expression,
1125   NULL,                         /* la_get_symbol_name_matcher */
1126   iterate_over_symbols,
1127   default_search_name_hash,
1128   &default_varobj_ops,
1129   NULL,
1130   NULL,
1131   LANG_MAGIC
1132 };