1 /* C language support routines for GDB, the GNU debugger.
3 Copyright (C) 1992-2021 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
23 #include "expression.h"
24 #include "parser-defs.h"
28 #include "c-support.h"
30 #include "macroscope.h"
34 #include "cp-support.h"
35 #include "gdb_obstack.h"
39 #include "compile/compile-internal.h"
42 /* Given a C string type, STR_TYPE, return the corresponding target
43 character set name. */
46 charset_for_string_type (c_string_type str_type
, struct gdbarch
*gdbarch
)
48 switch (str_type
& ~C_CHAR
)
51 return target_charset (gdbarch
);
53 return target_wide_charset (gdbarch
);
55 /* FIXME: UTF-16 is not always correct. */
56 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
)
61 /* FIXME: UTF-32 is not always correct. */
62 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
)
67 internal_error (__FILE__
, __LINE__
, _("unhandled c_string_type"));
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
77 classify_type (struct type
*elttype
, struct gdbarch
*gdbarch
,
78 const char **encoding
)
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. */
89 const char *name
= elttype
->name ();
91 if (elttype
->code () == TYPE_CODE_CHAR
|| !name
)
97 if (!strcmp (name
, "wchar_t"))
103 if (!strcmp (name
, "char16_t"))
109 if (!strcmp (name
, "char32_t"))
115 if (elttype
->code () != TYPE_CODE_TYPEDEF
)
118 /* Call for side effects. */
119 check_typedef (elttype
);
121 if (TYPE_TARGET_TYPE (elttype
))
122 elttype
= TYPE_TARGET_TYPE (elttype
);
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
);
137 *encoding
= charset_for_string_type (result
, gdbarch
);
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. */
147 c_emit_char (int c
, struct type
*type
,
148 struct ui_file
*stream
, int quoter
)
150 const char *encoding
;
152 classify_type (type
, type
->arch (), &encoding
);
153 generic_emit_char (c
, type
, stream
, quoter
, encoding
);
156 /* See language.h. */
159 language_defn::printchar (int c
, struct type
*type
,
160 struct ui_file
* stream
) const
162 c_string_type str_type
;
164 str_type
= classify_type (type
, type
->arch (), NULL
);
170 fputc_filtered ('L', stream
);
173 fputc_filtered ('u', stream
);
176 fputc_filtered ('U', stream
);
180 fputc_filtered ('\'', stream
);
181 emitchar (c
, type
, stream
, '\'');
182 fputc_filtered ('\'', stream
);
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. */
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
)
198 c_string_type str_type
;
199 const char *type_encoding
;
200 const char *encoding
;
202 str_type
= (classify_type (type
, type
->arch (), &type_encoding
)
209 fputs_filtered ("L", stream
);
212 fputs_filtered ("u", stream
);
215 fputs_filtered ("U", stream
);
219 encoding
= (user_encoding
&& *user_encoding
) ? user_encoding
: type_encoding
;
221 generic_printstr (stream
, type
, string
, length
, encoding
, force_ellipses
,
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.
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.
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
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
)
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
);
255 if (element_type
== NULL
)
258 if (type
->code () == TYPE_CODE_ARRAY
)
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
)
265 LONGEST low_bound
, high_bound
;
267 get_discrete_bounds (type
->field (0).type (),
268 &low_bound
, &high_bound
);
269 fetchlimit
= high_bound
- low_bound
+ 1;
272 fetchlimit
= UINT_MAX
;
274 else if (type
->code () == TYPE_CODE_PTR
)
275 fetchlimit
= UINT_MAX
;
277 /* We work only with arrays and pointers. */
280 if (! c_textual_element_type (element_type
, 0))
282 classify_type (element_type
, element_type
->arch (), charset
);
283 width
= TYPE_LENGTH (element_type
);
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
290 An array is assumed to live in GDB's memory, so we take this path
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
))
305 const gdb_byte
*contents
= value_contents (value
);
307 /* If a length is specified, use that. */
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)
317 /* I is now either a user-defined length, the number of non-null
318 characters, or FETCHLIMIT. */
320 buffer
->reset ((gdb_byte
*) xmalloc (*length
));
321 memcpy (buffer
->get (), contents
, *length
);
326 /* value_as_address does not return an address for an array when
327 c_style_arrays is false, so we handle that specially
330 if (type
->code () == TYPE_CODE_ARRAY
)
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
);
338 addr
= value_as_address (value
);
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. */
353 fetchlimit
= UINT_MAX
;
355 err
= read_string (addr
, *length
, width
, fetchlimit
,
356 byte_order
, buffer
, length
);
358 memory_error (TARGET_XFER_E_IO
, addr
);
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
365 if (req_length
== -1)
366 /* If the last character is null, subtract it from LENGTH. */
368 && extract_unsigned_integer (buffer
->get () + *length
- width
,
369 width
, byte_order
) == 0)
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. */
376 *length
= *length
/ width
;
378 *char_type
= element_type
;
384 std::string type_str
= type_to_string (type
);
385 if (!type_str
.empty ())
387 error (_("Trying to read string with inappropriate type `%s'."),
391 error (_("Trying to read string with inappropriate type."));
396 /* Evaluating C and C++ expressions. */
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. */
405 convert_ucn (const char *p
, const char *limit
, const char *dest_charset
,
406 struct obstack
*output
, int length
)
408 unsigned long result
= 0;
412 for (i
= 0; i
< length
&& p
< limit
&& ISXDIGIT (*p
); ++i
, ++p
)
413 result
= (result
<< 4) + host_hex_value (*p
);
415 for (i
= 3; i
>= 0; --i
)
417 data
[i
] = result
& 0xff;
421 convert_between_encodings ("UTF-32BE", dest_charset
, data
,
422 4, 4, output
, translit_none
);
427 /* Emit a character, VALUE, which was specified numerically, to
428 OUTPUT. TYPE is the target character type. */
431 emit_numeric_character (struct type
*type
, unsigned long value
,
432 struct obstack
*output
)
436 buffer
= (gdb_byte
*) alloca (TYPE_LENGTH (type
));
437 pack_long (buffer
, type
, value
);
438 obstack_grow (output
, buffer
, TYPE_LENGTH (type
));
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. */
447 convert_octal (struct type
*type
, const char *p
,
448 const char *limit
, struct obstack
*output
)
451 unsigned long value
= 0;
454 i
< 3 && p
< limit
&& ISDIGIT (*p
) && *p
!= '8' && *p
!= '9';
457 value
= 8 * value
+ host_hex_value (*p
);
461 emit_numeric_character (type
, value
, output
);
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. */
472 convert_hex (struct type
*type
, const char *p
,
473 const char *limit
, struct obstack
*output
)
475 unsigned long value
= 0;
477 while (p
< limit
&& ISXDIGIT (*p
))
479 value
= 16 * value
+ host_hex_value (*p
);
483 emit_numeric_character (type
, value
, output
);
492 error (_("Malformed escape sequence")); \
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. */
503 convert_escape (struct type
*type
, const char *dest_charset
,
504 const char *p
, const char *limit
, struct obstack
*output
)
506 /* Skip the backslash. */
512 obstack_1grow (output
, '\\');
519 error (_("\\x used with no following hex digits."));
520 p
= convert_hex (type
, p
, limit
, output
);
531 p
= convert_octal (type
, p
, limit
, output
);
537 int length
= *p
== 'u' ? 4 : 8;
541 error (_("\\u used with no following hex digits"));
542 p
= convert_ucn (p
, limit
, dest_charset
, output
, length
);
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. */
556 parse_one_string (struct obstack
*output
, const char *data
, int len
,
557 const char *dest_charset
, struct type
*type
)
565 const char *p
= data
;
567 /* Look for next escape, or the end of the input. */
568 while (p
< limit
&& *p
!= '\\')
570 /* If we saw a run of characters, convert them all. */
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. */
577 p
= convert_escape (type
, dest_charset
, p
, limit
, output
);
582 /* Expression evaluator for the C language family. Most operations
583 are delegated to evaluate_subexp_standard; see that function for a
584 description of the arguments. */
587 evaluate_subexp_c (struct type
*expect_type
, struct expression
*exp
,
588 int *pos
, enum noside noside
)
590 enum exp_opcode op
= exp
->elts
[*pos
].opcode
;
598 struct value
*result
;
599 c_string_type dest_type
;
600 const char *dest_charset
;
601 int satisfy_expected
= 0;
606 oplen
= longest_to_int (exp
->elts
[*pos
].longconst
);
609 limit
= *pos
+ BYTES_TO_EXP_ELEM (oplen
+ 1);
610 dest_type
= ((enum c_string_type_values
)
611 longest_to_int (exp
->elts
[*pos
].longconst
));
612 switch (dest_type
& ~C_CHAR
)
615 type
= language_string_char_type (exp
->language_defn
,
619 type
= lookup_typename (exp
->language_defn
, "wchar_t", NULL
, 0);
622 type
= lookup_typename (exp
->language_defn
, "char16_t", NULL
, 0);
625 type
= lookup_typename (exp
->language_defn
, "char32_t", NULL
, 0);
628 internal_error (__FILE__
, __LINE__
, _("unhandled c_string_type"));
631 /* Ensure TYPE_LENGTH is valid for TYPE. */
632 check_typedef (type
);
634 /* If the caller expects an array of some integral type,
635 satisfy them. If something odder is expected, rely on the
637 if (expect_type
&& expect_type
->code () == TYPE_CODE_ARRAY
)
639 struct type
*element_type
640 = check_typedef (TYPE_TARGET_TYPE (expect_type
));
642 if (element_type
->code () == TYPE_CODE_INT
643 || element_type
->code () == TYPE_CODE_CHAR
)
646 satisfy_expected
= 1;
650 dest_charset
= charset_for_string_type (dest_type
, exp
->gdbarch
);
657 len
= longest_to_int (exp
->elts
[*pos
].longconst
);
660 if (noside
!= EVAL_SKIP
)
661 parse_one_string (&output
, &exp
->elts
[*pos
].string
, len
,
663 *pos
+= BYTES_TO_EXP_ELEM (len
);
666 /* Skip the trailing length and opcode. */
669 if (noside
== EVAL_SKIP
)
671 /* Return a dummy value of the appropriate type. */
672 if (expect_type
!= NULL
)
673 result
= allocate_value (expect_type
);
674 else if ((dest_type
& C_CHAR
) != 0)
675 result
= allocate_value (type
);
677 result
= value_cstring ("", 0, type
);
681 if ((dest_type
& C_CHAR
) != 0)
685 if (obstack_object_size (&output
) != TYPE_LENGTH (type
))
686 error (_("Could not convert character "
687 "constant to target character set"));
688 value
= unpack_long (type
, (gdb_byte
*) obstack_base (&output
));
689 result
= value_from_longest (type
, value
);
695 /* Write the terminating character. */
696 for (i
= 0; i
< TYPE_LENGTH (type
); ++i
)
697 obstack_1grow (&output
, 0);
699 if (satisfy_expected
)
701 LONGEST low_bound
, high_bound
;
702 int element_size
= TYPE_LENGTH (type
);
704 if (!get_discrete_bounds (expect_type
->index_type (),
705 &low_bound
, &high_bound
))
708 high_bound
= (TYPE_LENGTH (expect_type
) / element_size
) - 1;
710 if (obstack_object_size (&output
) / element_size
711 > (high_bound
- low_bound
+ 1))
712 error (_("Too many array elements"));
714 result
= allocate_value (expect_type
);
715 memcpy (value_contents_raw (result
), obstack_base (&output
),
716 obstack_object_size (&output
));
719 result
= value_cstring ((const char *) obstack_base (&output
),
720 obstack_object_size (&output
),
730 return evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
737 c_string_operation::evaluate (struct type
*expect_type
,
738 struct expression
*exp
,
742 struct value
*result
;
743 c_string_type dest_type
;
744 const char *dest_charset
;
745 int satisfy_expected
= 0;
749 dest_type
= std::get
<0> (m_storage
);
751 switch (dest_type
& ~C_CHAR
)
754 type
= language_string_char_type (exp
->language_defn
,
758 type
= lookup_typename (exp
->language_defn
, "wchar_t", NULL
, 0);
761 type
= lookup_typename (exp
->language_defn
, "char16_t", NULL
, 0);
764 type
= lookup_typename (exp
->language_defn
, "char32_t", NULL
, 0);
767 internal_error (__FILE__
, __LINE__
, _("unhandled c_string_type"));
770 /* Ensure TYPE_LENGTH is valid for TYPE. */
771 check_typedef (type
);
773 /* If the caller expects an array of some integral type,
774 satisfy them. If something odder is expected, rely on the
776 if (expect_type
&& expect_type
->code () == TYPE_CODE_ARRAY
)
778 struct type
*element_type
779 = check_typedef (TYPE_TARGET_TYPE (expect_type
));
781 if (element_type
->code () == TYPE_CODE_INT
782 || element_type
->code () == TYPE_CODE_CHAR
)
785 satisfy_expected
= 1;
789 dest_charset
= charset_for_string_type (dest_type
, exp
->gdbarch
);
791 if (noside
!= EVAL_SKIP
)
793 for (const std::string
&item
: std::get
<1> (m_storage
))
794 parse_one_string (&output
, item
.c_str (), item
.size (),
798 if (noside
== EVAL_SKIP
)
800 /* Return a dummy value of the appropriate type. */
801 if (expect_type
!= NULL
)
802 result
= allocate_value (expect_type
);
803 else if ((dest_type
& C_CHAR
) != 0)
804 result
= allocate_value (type
);
806 result
= value_cstring ("", 0, type
);
810 if ((dest_type
& C_CHAR
) != 0)
814 if (obstack_object_size (&output
) != TYPE_LENGTH (type
))
815 error (_("Could not convert character "
816 "constant to target character set"));
817 value
= unpack_long (type
, (gdb_byte
*) obstack_base (&output
));
818 result
= value_from_longest (type
, value
);
824 /* Write the terminating character. */
825 for (i
= 0; i
< TYPE_LENGTH (type
); ++i
)
826 obstack_1grow (&output
, 0);
828 if (satisfy_expected
)
830 LONGEST low_bound
, high_bound
;
831 int element_size
= TYPE_LENGTH (type
);
833 if (!get_discrete_bounds (expect_type
->index_type (),
834 &low_bound
, &high_bound
))
837 high_bound
= (TYPE_LENGTH (expect_type
) / element_size
) - 1;
839 if (obstack_object_size (&output
) / element_size
840 > (high_bound
- low_bound
+ 1))
841 error (_("Too many array elements"));
843 result
= allocate_value (expect_type
);
844 memcpy (value_contents_raw (result
), obstack_base (&output
),
845 obstack_object_size (&output
));
848 result
= value_cstring ((const char *) obstack_base (&output
),
849 obstack_object_size (&output
),
855 } /* namespace expr */
861 c_is_string_type_p (struct type
*type
)
863 type
= check_typedef (type
);
864 while (type
->code () == TYPE_CODE_REF
)
866 type
= TYPE_TARGET_TYPE (type
);
867 type
= check_typedef (type
);
870 switch (type
->code ())
872 case TYPE_CODE_ARRAY
:
874 /* See if target type looks like a string. */
875 struct type
*array_target_type
= TYPE_TARGET_TYPE (type
);
876 return (TYPE_LENGTH (type
) > 0
877 && TYPE_LENGTH (array_target_type
) > 0
878 && c_textual_element_type (array_target_type
, 0));
880 case TYPE_CODE_STRING
:
884 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
885 return c_textual_element_type (element_type
, 0);
895 /* Table mapping opcodes into strings for printing operators
896 and precedences of the operators. */
898 const struct op_print c_op_print_tab
[] =
900 {",", BINOP_COMMA
, PREC_COMMA
, 0},
901 {"=", BINOP_ASSIGN
, PREC_ASSIGN
, 1},
902 {"||", BINOP_LOGICAL_OR
, PREC_LOGICAL_OR
, 0},
903 {"&&", BINOP_LOGICAL_AND
, PREC_LOGICAL_AND
, 0},
904 {"|", BINOP_BITWISE_IOR
, PREC_BITWISE_IOR
, 0},
905 {"^", BINOP_BITWISE_XOR
, PREC_BITWISE_XOR
, 0},
906 {"&", BINOP_BITWISE_AND
, PREC_BITWISE_AND
, 0},
907 {"==", BINOP_EQUAL
, PREC_EQUAL
, 0},
908 {"!=", BINOP_NOTEQUAL
, PREC_EQUAL
, 0},
909 {"<=", BINOP_LEQ
, PREC_ORDER
, 0},
910 {">=", BINOP_GEQ
, PREC_ORDER
, 0},
911 {">", BINOP_GTR
, PREC_ORDER
, 0},
912 {"<", BINOP_LESS
, PREC_ORDER
, 0},
913 {">>", BINOP_RSH
, PREC_SHIFT
, 0},
914 {"<<", BINOP_LSH
, PREC_SHIFT
, 0},
915 {"+", BINOP_ADD
, PREC_ADD
, 0},
916 {"-", BINOP_SUB
, PREC_ADD
, 0},
917 {"*", BINOP_MUL
, PREC_MUL
, 0},
918 {"/", BINOP_DIV
, PREC_MUL
, 0},
919 {"%", BINOP_REM
, PREC_MUL
, 0},
920 {"@", BINOP_REPEAT
, PREC_REPEAT
, 0},
921 {"+", UNOP_PLUS
, PREC_PREFIX
, 0},
922 {"-", UNOP_NEG
, PREC_PREFIX
, 0},
923 {"!", UNOP_LOGICAL_NOT
, PREC_PREFIX
, 0},
924 {"~", UNOP_COMPLEMENT
, PREC_PREFIX
, 0},
925 {"*", UNOP_IND
, PREC_PREFIX
, 0},
926 {"&", UNOP_ADDR
, PREC_PREFIX
, 0},
927 {"sizeof ", UNOP_SIZEOF
, PREC_PREFIX
, 0},
928 {"alignof ", UNOP_ALIGNOF
, PREC_PREFIX
, 0},
929 {"++", UNOP_PREINCREMENT
, PREC_PREFIX
, 0},
930 {"--", UNOP_PREDECREMENT
, PREC_PREFIX
, 0},
931 {NULL
, OP_NULL
, PREC_PREFIX
, 0}
936 c_language_arch_info (struct gdbarch
*gdbarch
,
937 struct language_arch_info
*lai
)
939 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
941 /* Helper function to allow shorter lines below. */
942 auto add
= [&] (struct type
* t
)
944 lai
->add_primitive_type (t
);
947 add (builtin
->builtin_int
);
948 add (builtin
->builtin_long
);
949 add (builtin
->builtin_short
);
950 add (builtin
->builtin_char
);
951 add (builtin
->builtin_float
);
952 add (builtin
->builtin_double
);
953 add (builtin
->builtin_void
);
954 add (builtin
->builtin_long_long
);
955 add (builtin
->builtin_signed_char
);
956 add (builtin
->builtin_unsigned_char
);
957 add (builtin
->builtin_unsigned_short
);
958 add (builtin
->builtin_unsigned_int
);
959 add (builtin
->builtin_unsigned_long
);
960 add (builtin
->builtin_unsigned_long_long
);
961 add (builtin
->builtin_long_double
);
962 add (builtin
->builtin_complex
);
963 add (builtin
->builtin_double_complex
);
964 add (builtin
->builtin_decfloat
);
965 add (builtin
->builtin_decdouble
);
966 add (builtin
->builtin_declong
);
968 lai
->set_string_char_type (builtin
->builtin_char
);
969 lai
->set_bool_type (builtin
->builtin_int
);
972 const struct exp_descriptor exp_descriptor_c
=
974 print_subexp_standard
,
975 operator_length_standard
,
976 operator_check_standard
,
977 dump_subexp_body_standard
,
981 /* Class representing the C language. */
983 class c_language
: public language_defn
987 : language_defn (language_c
)
990 /* See language.h. */
992 const char *name () const override
995 /* See language.h. */
997 const char *natural_name () const override
1000 /* See language.h. */
1002 const std::vector
<const char *> &filename_extensions () const override
1004 static const std::vector
<const char *> extensions
= { ".c" };
1008 /* See language.h. */
1009 void language_arch_info (struct gdbarch
*gdbarch
,
1010 struct language_arch_info
*lai
) const override
1012 c_language_arch_info (gdbarch
, lai
);
1015 /* See language.h. */
1016 std::unique_ptr
<compile_instance
> get_compile_instance () const override
1018 return c_get_compile_context ();
1021 /* See language.h. */
1022 std::string
compute_program (compile_instance
*inst
,
1024 struct gdbarch
*gdbarch
,
1025 const struct block
*expr_block
,
1026 CORE_ADDR expr_pc
) const override
1028 return c_compute_program (inst
, input
, gdbarch
, expr_block
, expr_pc
);
1031 /* See language.h. */
1033 void print_type (struct type
*type
, const char *varstring
,
1034 struct ui_file
*stream
, int show
, int level
,
1035 const struct type_print_options
*flags
) const override
1037 c_print_type (type
, varstring
, stream
, show
, level
, flags
);
1040 /* See language.h. */
1042 bool store_sym_names_in_linkage_form_p () const override
1045 /* See language.h. */
1047 enum macro_expansion
macro_expansion () const override
1048 { return macro_expansion_c
; }
1050 /* See language.h. */
1052 const struct exp_descriptor
*expression_ops () const override
1053 { return &exp_descriptor_c
; }
1055 /* See language.h. */
1057 const struct op_print
*opcode_print_table () const override
1058 { return c_op_print_tab
; }
1061 /* Single instance of the C language class. */
1063 static c_language c_language_defn
;
1065 /* A class for the C++ language. */
1067 class cplus_language
: public language_defn
1071 : language_defn (language_cplus
)
1074 /* See language.h. */
1076 const char *name () const override
1079 /* See language.h. */
1081 const char *natural_name () const override
1084 /* See language.h. */
1086 const std::vector
<const char *> &filename_extensions () const override
1088 static const std::vector
<const char *> extensions
1089 = { ".C", ".cc", ".cp", ".cpp", ".cxx", ".c++" };
1093 /* See language.h. */
1095 struct language_pass_by_ref_info pass_by_reference_info
1096 (struct type
*type
) const override
1098 return cp_pass_by_reference (type
);
1101 /* See language.h. */
1102 void language_arch_info (struct gdbarch
*gdbarch
,
1103 struct language_arch_info
*lai
) const override
1105 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
1107 /* Helper function to allow shorter lines below. */
1108 auto add
= [&] (struct type
* t
)
1110 lai
->add_primitive_type (t
);
1113 add (builtin
->builtin_int
);
1114 add (builtin
->builtin_long
);
1115 add (builtin
->builtin_short
);
1116 add (builtin
->builtin_char
);
1117 add (builtin
->builtin_float
);
1118 add (builtin
->builtin_double
);
1119 add (builtin
->builtin_void
);
1120 add (builtin
->builtin_long_long
);
1121 add (builtin
->builtin_signed_char
);
1122 add (builtin
->builtin_unsigned_char
);
1123 add (builtin
->builtin_unsigned_short
);
1124 add (builtin
->builtin_unsigned_int
);
1125 add (builtin
->builtin_unsigned_long
);
1126 add (builtin
->builtin_unsigned_long_long
);
1127 add (builtin
->builtin_long_double
);
1128 add (builtin
->builtin_complex
);
1129 add (builtin
->builtin_double_complex
);
1130 add (builtin
->builtin_bool
);
1131 add (builtin
->builtin_decfloat
);
1132 add (builtin
->builtin_decdouble
);
1133 add (builtin
->builtin_declong
);
1134 add (builtin
->builtin_char16
);
1135 add (builtin
->builtin_char32
);
1136 add (builtin
->builtin_wchar
);
1138 lai
->set_string_char_type (builtin
->builtin_char
);
1139 lai
->set_bool_type (builtin
->builtin_bool
, "bool");
1142 /* See language.h. */
1143 struct type
*lookup_transparent_type (const char *name
) const override
1145 return cp_lookup_transparent_type (name
);
1148 /* See language.h. */
1149 std::unique_ptr
<compile_instance
> get_compile_instance () const override
1151 return cplus_get_compile_context ();
1154 /* See language.h. */
1155 std::string
compute_program (compile_instance
*inst
,
1157 struct gdbarch
*gdbarch
,
1158 const struct block
*expr_block
,
1159 CORE_ADDR expr_pc
) const override
1161 return cplus_compute_program (inst
, input
, gdbarch
, expr_block
, expr_pc
);
1164 /* See language.h. */
1165 unsigned int search_name_hash (const char *name
) const override
1167 return cp_search_name_hash (name
);
1170 /* See language.h. */
1171 bool sniff_from_mangled_name (const char *mangled
,
1172 char **demangled
) const override
1174 *demangled
= gdb_demangle (mangled
, DMGL_PARAMS
| DMGL_ANSI
);
1175 return *demangled
!= NULL
;
1178 /* See language.h. */
1180 char *demangle_symbol (const char *mangled
, int options
) const override
1182 return gdb_demangle (mangled
, options
);
1185 /* See language.h. */
1187 void print_type (struct type
*type
, const char *varstring
,
1188 struct ui_file
*stream
, int show
, int level
,
1189 const struct type_print_options
*flags
) const override
1191 c_print_type (type
, varstring
, stream
, show
, level
, flags
);
1194 /* See language.h. */
1196 CORE_ADDR
skip_trampoline (struct frame_info
*fi
,
1197 CORE_ADDR pc
) const override
1199 return cplus_skip_trampoline (fi
, pc
);
1202 /* See language.h. */
1204 char *class_name_from_physname (const char *physname
) const override
1206 return cp_class_name_from_physname (physname
);
1209 /* See language.h. */
1211 struct block_symbol lookup_symbol_nonlocal
1212 (const char *name
, const struct block
*block
,
1213 const domain_enum domain
) const override
1215 return cp_lookup_symbol_nonlocal (this, name
, block
, domain
);
1218 /* See language.h. */
1220 const char *name_of_this () const override
1223 /* See language.h. */
1225 enum macro_expansion
macro_expansion () const override
1226 { return macro_expansion_c
; }
1228 /* See language.h. */
1230 const struct lang_varobj_ops
*varobj_ops () const override
1231 { return &cplus_varobj_ops
; }
1233 /* See language.h. */
1235 const struct exp_descriptor
*expression_ops () const override
1236 { return &exp_descriptor_c
; }
1238 /* See language.h. */
1240 const struct op_print
*opcode_print_table () const override
1241 { return c_op_print_tab
; }
1245 /* See language.h. */
1247 symbol_name_matcher_ftype
*get_symbol_name_matcher_inner
1248 (const lookup_name_info
&lookup_name
) const override
1250 return cp_get_symbol_name_matcher (lookup_name
);
1254 /* The single instance of the C++ language class. */
1256 static cplus_language cplus_language_defn
;
1258 /* A class for the ASM language. */
1260 class asm_language
: public language_defn
1264 : language_defn (language_asm
)
1267 /* See language.h. */
1269 const char *name () const override
1272 /* See language.h. */
1274 const char *natural_name () const override
1275 { return "Assembly"; }
1277 /* See language.h. */
1279 const std::vector
<const char *> &filename_extensions () const override
1281 static const std::vector
<const char *> extensions
1282 = { ".s", ".sx", ".S" };
1288 FIXME: Should this have its own arch info method? */
1289 void language_arch_info (struct gdbarch
*gdbarch
,
1290 struct language_arch_info
*lai
) const override
1292 c_language_arch_info (gdbarch
, lai
);
1295 /* See language.h. */
1297 void print_type (struct type
*type
, const char *varstring
,
1298 struct ui_file
*stream
, int show
, int level
,
1299 const struct type_print_options
*flags
) const override
1301 c_print_type (type
, varstring
, stream
, show
, level
, flags
);
1304 /* See language.h. */
1306 bool store_sym_names_in_linkage_form_p () const override
1309 /* See language.h. */
1311 enum macro_expansion
macro_expansion () const override
1312 { return macro_expansion_c
; }
1314 /* See language.h. */
1316 const struct exp_descriptor
*expression_ops () const override
1317 { return &exp_descriptor_c
; }
1319 /* See language.h. */
1321 const struct op_print
*opcode_print_table () const override
1322 { return c_op_print_tab
; }
1325 /* The single instance of the ASM language class. */
1326 static asm_language asm_language_defn
;
1328 /* A class for the minimal language. This does not represent a real
1329 language. It just provides a minimal support a-la-C that should allow
1330 users to do some simple operations when debugging applications that use
1331 a language currently not supported by GDB. */
1333 class minimal_language
: public language_defn
1337 : language_defn (language_minimal
)
1340 /* See language.h. */
1342 const char *name () const override
1343 { return "minimal"; }
1345 /* See language.h. */
1347 const char *natural_name () const override
1348 { return "Minimal"; }
1350 /* See language.h. */
1351 void language_arch_info (struct gdbarch
*gdbarch
,
1352 struct language_arch_info
*lai
) const override
1354 c_language_arch_info (gdbarch
, lai
);
1357 /* See language.h. */
1359 void print_type (struct type
*type
, const char *varstring
,
1360 struct ui_file
*stream
, int show
, int level
,
1361 const struct type_print_options
*flags
) const override
1363 c_print_type (type
, varstring
, stream
, show
, level
, flags
);
1366 /* See language.h. */
1368 bool store_sym_names_in_linkage_form_p () const override
1371 /* See language.h. */
1373 enum macro_expansion
macro_expansion () const override
1374 { return macro_expansion_c
; }
1376 /* See language.h. */
1378 const struct exp_descriptor
*expression_ops () const override
1379 { return &exp_descriptor_c
; }
1381 /* See language.h. */
1383 const struct op_print
*opcode_print_table () const override
1384 { return c_op_print_tab
; }
1387 /* The single instance of the minimal language class. */
1388 static minimal_language minimal_language_defn
;