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