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