1 /* C language support routines for GDB, the GNU debugger.
3 Copyright (C) 1992-2020 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"
40 class compile_instance
;
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
, get_type_arch (type
), &encoding
);
153 generic_emit_char (c
, type
, stream
, quoter
, encoding
);
157 c_printchar (int c
, struct type
*type
, struct ui_file
*stream
)
159 c_string_type str_type
;
161 str_type
= classify_type (type
, get_type_arch (type
), NULL
);
167 fputc_filtered ('L', stream
);
170 fputc_filtered ('u', stream
);
173 fputc_filtered ('U', stream
);
177 fputc_filtered ('\'', stream
);
178 LA_EMIT_CHAR (c
, type
, stream
, '\'');
179 fputc_filtered ('\'', stream
);
182 /* Print the character string STRING, printing at most LENGTH
183 characters. LENGTH is -1 if the string is nul terminated. Each
184 character is WIDTH bytes long. Printing stops early if the number
185 hits print_max; repeat counts are printed as appropriate. Print
186 ellipses at the end if we had to stop before printing LENGTH
187 characters, or if FORCE_ELLIPSES. */
190 c_printstr (struct ui_file
*stream
, struct type
*type
,
191 const gdb_byte
*string
, unsigned int length
,
192 const char *user_encoding
, int force_ellipses
,
193 const struct value_print_options
*options
)
195 c_string_type str_type
;
196 const char *type_encoding
;
197 const char *encoding
;
199 str_type
= (classify_type (type
, get_type_arch (type
), &type_encoding
)
206 fputs_filtered ("L", stream
);
209 fputs_filtered ("u", stream
);
212 fputs_filtered ("U", stream
);
216 encoding
= (user_encoding
&& *user_encoding
) ? user_encoding
: type_encoding
;
218 generic_printstr (stream
, type
, string
, length
, encoding
, force_ellipses
,
222 /* Obtain a C string from the inferior storing it in a newly allocated
223 buffer in BUFFER, which should be freed by the caller. If the in-
224 and out-parameter *LENGTH is specified at -1, the string is read
225 until a null character of the appropriate width is found, otherwise
226 the string is read to the length of characters specified. The size
227 of a character is determined by the length of the target type of
228 the pointer or array.
230 If VALUE is an array with a known length, and *LENGTH is -1,
231 the function will not read past the end of the array. However, any
232 declared size of the array is ignored if *LENGTH > 0.
234 On completion, *LENGTH will be set to the size of the string read in
235 characters. (If a length of -1 is specified, the length returned
236 will not include the null character). CHARSET is always set to the
240 c_get_string (struct value
*value
, gdb::unique_xmalloc_ptr
<gdb_byte
> *buffer
,
241 int *length
, struct type
**char_type
,
242 const char **charset
)
245 unsigned int fetchlimit
;
246 struct type
*type
= check_typedef (value_type (value
));
247 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
248 int req_length
= *length
;
249 enum bfd_endian byte_order
250 = type_byte_order (type
);
252 if (element_type
== NULL
)
255 if (type
->code () == TYPE_CODE_ARRAY
)
257 /* If we know the size of the array, we can use it as a limit on
258 the number of characters to be fetched. */
259 if (type
->num_fields () == 1
260 && type
->field (0).type ()->code () == TYPE_CODE_RANGE
)
262 LONGEST low_bound
, high_bound
;
264 get_discrete_bounds (type
->field (0).type (),
265 &low_bound
, &high_bound
);
266 fetchlimit
= high_bound
- low_bound
+ 1;
269 fetchlimit
= UINT_MAX
;
271 else if (type
->code () == TYPE_CODE_PTR
)
272 fetchlimit
= UINT_MAX
;
274 /* We work only with arrays and pointers. */
277 if (! c_textual_element_type (element_type
, 0))
279 classify_type (element_type
, get_type_arch (element_type
), charset
);
280 width
= TYPE_LENGTH (element_type
);
282 /* If the string lives in GDB's memory instead of the inferior's,
283 then we just need to copy it to BUFFER. Also, since such strings
284 are arrays with known size, FETCHLIMIT will hold the size of the
287 An array is assumed to live in GDB's memory, so we take this path
290 However, it's possible for the caller to request more array
291 elements than apparently exist -- this can happen when using the
292 C struct hack. So, only do this if either no length was
293 specified, or the length is within the existing bounds. This
294 avoids running off the end of the value's contents. */
295 if ((VALUE_LVAL (value
) == not_lval
296 || VALUE_LVAL (value
) == lval_internalvar
297 || type
->code () == TYPE_CODE_ARRAY
)
298 && fetchlimit
!= UINT_MAX
299 && (*length
< 0 || *length
<= fetchlimit
))
302 const gdb_byte
*contents
= value_contents (value
);
304 /* If a length is specified, use that. */
308 /* Otherwise, look for a null character. */
309 for (i
= 0; i
< fetchlimit
; i
++)
310 if (extract_unsigned_integer (contents
+ i
* width
,
311 width
, byte_order
) == 0)
314 /* I is now either a user-defined length, the number of non-null
315 characters, or FETCHLIMIT. */
317 buffer
->reset ((gdb_byte
*) xmalloc (*length
));
318 memcpy (buffer
->get (), contents
, *length
);
323 /* value_as_address does not return an address for an array when
324 c_style_arrays is false, so we handle that specially
327 if (type
->code () == TYPE_CODE_ARRAY
)
329 if (VALUE_LVAL (value
) != lval_memory
)
330 error (_("Attempt to take address of value "
331 "not located in memory."));
332 addr
= value_address (value
);
335 addr
= value_as_address (value
);
337 /* Prior to the fix for PR 16196 read_string would ignore fetchlimit
338 if length > 0. The old "broken" behaviour is the behaviour we want:
339 The caller may want to fetch 100 bytes from a variable length array
340 implemented using the common idiom of having an array of length 1 at
341 the end of a struct. In this case we want to ignore the declared
342 size of the array. However, it's counterintuitive to implement that
343 behaviour in read_string: what does fetchlimit otherwise mean if
344 length > 0. Therefore we implement the behaviour we want here:
345 If *length > 0, don't specify a fetchlimit. This preserves the
346 previous behaviour. We could move this check above where we know
347 whether the array is declared with a fixed size, but we only want
348 to apply this behaviour when calling read_string. PR 16286. */
350 fetchlimit
= UINT_MAX
;
352 err
= read_string (addr
, *length
, width
, fetchlimit
,
353 byte_order
, buffer
, length
);
355 memory_error (TARGET_XFER_E_IO
, addr
);
358 /* If the LENGTH is specified at -1, we want to return the string
359 length up to the terminating null character. If an actual length
360 was specified, we want to return the length of exactly what was
362 if (req_length
== -1)
363 /* If the last character is null, subtract it from LENGTH. */
365 && extract_unsigned_integer (buffer
->get () + *length
- width
,
366 width
, byte_order
) == 0)
369 /* The read_string function will return the number of bytes read.
370 If length returned from read_string was > 0, return the number of
371 characters read by dividing the number of bytes by width. */
373 *length
= *length
/ width
;
375 *char_type
= element_type
;
381 std::string type_str
= type_to_string (type
);
382 if (!type_str
.empty ())
384 error (_("Trying to read string with inappropriate type `%s'."),
388 error (_("Trying to read string with inappropriate type."));
393 /* Evaluating C and C++ expressions. */
395 /* Convert a UCN. The digits of the UCN start at P and extend no
396 farther than LIMIT. DEST_CHARSET is the name of the character set
397 into which the UCN should be converted. The results are written to
398 OUTPUT. LENGTH is the maximum length of the UCN, either 4 or 8.
399 Returns a pointer to just after the final digit of the UCN. */
402 convert_ucn (char *p
, char *limit
, const char *dest_charset
,
403 struct obstack
*output
, int length
)
405 unsigned long result
= 0;
409 for (i
= 0; i
< length
&& p
< limit
&& ISXDIGIT (*p
); ++i
, ++p
)
410 result
= (result
<< 4) + host_hex_value (*p
);
412 for (i
= 3; i
>= 0; --i
)
414 data
[i
] = result
& 0xff;
418 convert_between_encodings ("UTF-32BE", dest_charset
, data
,
419 4, 4, output
, translit_none
);
424 /* Emit a character, VALUE, which was specified numerically, to
425 OUTPUT. TYPE is the target character type. */
428 emit_numeric_character (struct type
*type
, unsigned long value
,
429 struct obstack
*output
)
433 buffer
= (gdb_byte
*) alloca (TYPE_LENGTH (type
));
434 pack_long (buffer
, type
, value
);
435 obstack_grow (output
, buffer
, TYPE_LENGTH (type
));
438 /* Convert an octal escape sequence. TYPE is the target character
439 type. The digits of the escape sequence begin at P and extend no
440 farther than LIMIT. The result is written to OUTPUT. Returns a
441 pointer to just after the final digit of the escape sequence. */
444 convert_octal (struct type
*type
, char *p
,
445 char *limit
, struct obstack
*output
)
448 unsigned long value
= 0;
451 i
< 3 && p
< limit
&& ISDIGIT (*p
) && *p
!= '8' && *p
!= '9';
454 value
= 8 * value
+ host_hex_value (*p
);
458 emit_numeric_character (type
, value
, output
);
463 /* Convert a hex escape sequence. TYPE is the target character type.
464 The digits of the escape sequence begin at P and extend no farther
465 than LIMIT. The result is written to OUTPUT. Returns a pointer to
466 just after the final digit of the escape sequence. */
469 convert_hex (struct type
*type
, char *p
,
470 char *limit
, struct obstack
*output
)
472 unsigned long value
= 0;
474 while (p
< limit
&& ISXDIGIT (*p
))
476 value
= 16 * value
+ host_hex_value (*p
);
480 emit_numeric_character (type
, value
, output
);
489 error (_("Malformed escape sequence")); \
492 /* Convert an escape sequence to a target format. TYPE is the target
493 character type to use, and DEST_CHARSET is the name of the target
494 character set. The backslash of the escape sequence is at *P, and
495 the escape sequence will not extend past LIMIT. The results are
496 written to OUTPUT. Returns a pointer to just past the final
497 character of the escape sequence. */
500 convert_escape (struct type
*type
, const char *dest_charset
,
501 char *p
, char *limit
, struct obstack
*output
)
503 /* Skip the backslash. */
509 obstack_1grow (output
, '\\');
516 error (_("\\x used with no following hex digits."));
517 p
= convert_hex (type
, p
, limit
, output
);
528 p
= convert_octal (type
, p
, limit
, output
);
534 int length
= *p
== 'u' ? 4 : 8;
538 error (_("\\u used with no following hex digits"));
539 p
= convert_ucn (p
, limit
, dest_charset
, output
, length
);
546 /* Given a single string from a (C-specific) OP_STRING list, convert
547 it to a target string, handling escape sequences specially. The
548 output is written to OUTPUT. DATA is the input string, which has
549 length LEN. DEST_CHARSET is the name of the target character set,
550 and TYPE is the type of target character to use. */
553 parse_one_string (struct obstack
*output
, char *data
, int len
,
554 const char *dest_charset
, struct type
*type
)
564 /* Look for next escape, or the end of the input. */
565 while (p
< limit
&& *p
!= '\\')
567 /* If we saw a run of characters, convert them all. */
569 convert_between_encodings (host_charset (), dest_charset
,
570 (gdb_byte
*) data
, p
- data
, 1,
571 output
, translit_none
);
572 /* If we saw an escape, convert it. */
574 p
= convert_escape (type
, dest_charset
, p
, limit
, output
);
579 /* Expression evaluator for the C language family. Most operations
580 are delegated to evaluate_subexp_standard; see that function for a
581 description of the arguments. */
584 evaluate_subexp_c (struct type
*expect_type
, struct expression
*exp
,
585 int *pos
, enum noside noside
)
587 enum exp_opcode op
= exp
->elts
[*pos
].opcode
;
595 struct value
*result
;
596 c_string_type dest_type
;
597 const char *dest_charset
;
598 int satisfy_expected
= 0;
603 oplen
= longest_to_int (exp
->elts
[*pos
].longconst
);
606 limit
= *pos
+ BYTES_TO_EXP_ELEM (oplen
+ 1);
607 dest_type
= ((enum c_string_type_values
)
608 longest_to_int (exp
->elts
[*pos
].longconst
));
609 switch (dest_type
& ~C_CHAR
)
612 type
= language_string_char_type (exp
->language_defn
,
616 type
= lookup_typename (exp
->language_defn
, "wchar_t", NULL
, 0);
619 type
= lookup_typename (exp
->language_defn
, "char16_t", NULL
, 0);
622 type
= lookup_typename (exp
->language_defn
, "char32_t", NULL
, 0);
625 internal_error (__FILE__
, __LINE__
, _("unhandled c_string_type"));
628 /* Ensure TYPE_LENGTH is valid for TYPE. */
629 check_typedef (type
);
631 /* If the caller expects an array of some integral type,
632 satisfy them. If something odder is expected, rely on the
634 if (expect_type
&& expect_type
->code () == TYPE_CODE_ARRAY
)
636 struct type
*element_type
637 = check_typedef (TYPE_TARGET_TYPE (expect_type
));
639 if (element_type
->code () == TYPE_CODE_INT
640 || element_type
->code () == TYPE_CODE_CHAR
)
643 satisfy_expected
= 1;
647 dest_charset
= charset_for_string_type (dest_type
, exp
->gdbarch
);
654 len
= longest_to_int (exp
->elts
[*pos
].longconst
);
657 if (noside
!= EVAL_SKIP
)
658 parse_one_string (&output
, &exp
->elts
[*pos
].string
, len
,
660 *pos
+= BYTES_TO_EXP_ELEM (len
);
663 /* Skip the trailing length and opcode. */
666 if (noside
== EVAL_SKIP
)
668 /* Return a dummy value of the appropriate type. */
669 if (expect_type
!= NULL
)
670 result
= allocate_value (expect_type
);
671 else if ((dest_type
& C_CHAR
) != 0)
672 result
= allocate_value (type
);
674 result
= value_cstring ("", 0, type
);
678 if ((dest_type
& C_CHAR
) != 0)
682 if (obstack_object_size (&output
) != TYPE_LENGTH (type
))
683 error (_("Could not convert character "
684 "constant to target character set"));
685 value
= unpack_long (type
, (gdb_byte
*) obstack_base (&output
));
686 result
= value_from_longest (type
, value
);
692 /* Write the terminating character. */
693 for (i
= 0; i
< TYPE_LENGTH (type
); ++i
)
694 obstack_1grow (&output
, 0);
696 if (satisfy_expected
)
698 LONGEST low_bound
, high_bound
;
699 int element_size
= TYPE_LENGTH (type
);
701 if (get_discrete_bounds (expect_type
->index_type (),
702 &low_bound
, &high_bound
) < 0)
705 high_bound
= (TYPE_LENGTH (expect_type
) / element_size
) - 1;
707 if (obstack_object_size (&output
) / element_size
708 > (high_bound
- low_bound
+ 1))
709 error (_("Too many array elements"));
711 result
= allocate_value (expect_type
);
712 memcpy (value_contents_raw (result
), obstack_base (&output
),
713 obstack_object_size (&output
));
716 result
= value_cstring ((const char *) obstack_base (&output
),
717 obstack_object_size (&output
),
727 return evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
730 /* la_watch_location_expression for C. */
732 gdb::unique_xmalloc_ptr
<char>
733 c_watch_location_expression (struct type
*type
, CORE_ADDR addr
)
735 type
= check_typedef (TYPE_TARGET_TYPE (check_typedef (type
)));
736 std::string name
= type_to_string (type
);
737 return gdb::unique_xmalloc_ptr
<char>
738 (xstrprintf ("* (%s *) %s", name
.c_str (), core_addr_to_string (addr
)));
744 c_is_string_type_p (struct type
*type
)
746 type
= check_typedef (type
);
747 while (type
->code () == TYPE_CODE_REF
)
749 type
= TYPE_TARGET_TYPE (type
);
750 type
= check_typedef (type
);
753 switch (type
->code ())
755 case TYPE_CODE_ARRAY
:
757 /* See if target type looks like a string. */
758 struct type
*array_target_type
= TYPE_TARGET_TYPE (type
);
759 return (TYPE_LENGTH (type
) > 0
760 && TYPE_LENGTH (array_target_type
) > 0
761 && c_textual_element_type (array_target_type
, 0));
763 case TYPE_CODE_STRING
:
767 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
768 return c_textual_element_type (element_type
, 0);
778 /* Table mapping opcodes into strings for printing operators
779 and precedences of the operators. */
781 const struct op_print c_op_print_tab
[] =
783 {",", BINOP_COMMA
, PREC_COMMA
, 0},
784 {"=", BINOP_ASSIGN
, PREC_ASSIGN
, 1},
785 {"||", BINOP_LOGICAL_OR
, PREC_LOGICAL_OR
, 0},
786 {"&&", BINOP_LOGICAL_AND
, PREC_LOGICAL_AND
, 0},
787 {"|", BINOP_BITWISE_IOR
, PREC_BITWISE_IOR
, 0},
788 {"^", BINOP_BITWISE_XOR
, PREC_BITWISE_XOR
, 0},
789 {"&", BINOP_BITWISE_AND
, PREC_BITWISE_AND
, 0},
790 {"==", BINOP_EQUAL
, PREC_EQUAL
, 0},
791 {"!=", BINOP_NOTEQUAL
, PREC_EQUAL
, 0},
792 {"<=", BINOP_LEQ
, PREC_ORDER
, 0},
793 {">=", BINOP_GEQ
, PREC_ORDER
, 0},
794 {">", BINOP_GTR
, PREC_ORDER
, 0},
795 {"<", BINOP_LESS
, PREC_ORDER
, 0},
796 {">>", BINOP_RSH
, PREC_SHIFT
, 0},
797 {"<<", BINOP_LSH
, PREC_SHIFT
, 0},
798 {"+", BINOP_ADD
, PREC_ADD
, 0},
799 {"-", BINOP_SUB
, PREC_ADD
, 0},
800 {"*", BINOP_MUL
, PREC_MUL
, 0},
801 {"/", BINOP_DIV
, PREC_MUL
, 0},
802 {"%", BINOP_REM
, PREC_MUL
, 0},
803 {"@", BINOP_REPEAT
, PREC_REPEAT
, 0},
804 {"+", UNOP_PLUS
, PREC_PREFIX
, 0},
805 {"-", UNOP_NEG
, PREC_PREFIX
, 0},
806 {"!", UNOP_LOGICAL_NOT
, PREC_PREFIX
, 0},
807 {"~", UNOP_COMPLEMENT
, PREC_PREFIX
, 0},
808 {"*", UNOP_IND
, PREC_PREFIX
, 0},
809 {"&", UNOP_ADDR
, PREC_PREFIX
, 0},
810 {"sizeof ", UNOP_SIZEOF
, PREC_PREFIX
, 0},
811 {"alignof ", UNOP_ALIGNOF
, PREC_PREFIX
, 0},
812 {"++", UNOP_PREINCREMENT
, PREC_PREFIX
, 0},
813 {"--", UNOP_PREDECREMENT
, PREC_PREFIX
, 0},
814 {NULL
, OP_NULL
, PREC_PREFIX
, 0}
817 enum c_primitive_types
{
818 c_primitive_type_int
,
819 c_primitive_type_long
,
820 c_primitive_type_short
,
821 c_primitive_type_char
,
822 c_primitive_type_float
,
823 c_primitive_type_double
,
824 c_primitive_type_void
,
825 c_primitive_type_long_long
,
826 c_primitive_type_signed_char
,
827 c_primitive_type_unsigned_char
,
828 c_primitive_type_unsigned_short
,
829 c_primitive_type_unsigned_int
,
830 c_primitive_type_unsigned_long
,
831 c_primitive_type_unsigned_long_long
,
832 c_primitive_type_long_double
,
833 c_primitive_type_complex
,
834 c_primitive_type_double_complex
,
835 c_primitive_type_decfloat
,
836 c_primitive_type_decdouble
,
837 c_primitive_type_declong
,
842 c_language_arch_info (struct gdbarch
*gdbarch
,
843 struct language_arch_info
*lai
)
845 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
847 lai
->string_char_type
= builtin
->builtin_char
;
848 lai
->primitive_type_vector
849 = GDBARCH_OBSTACK_CALLOC (gdbarch
, nr_c_primitive_types
+ 1,
851 lai
->primitive_type_vector
[c_primitive_type_int
] = builtin
->builtin_int
;
852 lai
->primitive_type_vector
[c_primitive_type_long
] = builtin
->builtin_long
;
853 lai
->primitive_type_vector
[c_primitive_type_short
] = builtin
->builtin_short
;
854 lai
->primitive_type_vector
[c_primitive_type_char
] = builtin
->builtin_char
;
855 lai
->primitive_type_vector
[c_primitive_type_float
] = builtin
->builtin_float
;
856 lai
->primitive_type_vector
[c_primitive_type_double
] = builtin
->builtin_double
;
857 lai
->primitive_type_vector
[c_primitive_type_void
] = builtin
->builtin_void
;
858 lai
->primitive_type_vector
[c_primitive_type_long_long
] = builtin
->builtin_long_long
;
859 lai
->primitive_type_vector
[c_primitive_type_signed_char
] = builtin
->builtin_signed_char
;
860 lai
->primitive_type_vector
[c_primitive_type_unsigned_char
] = builtin
->builtin_unsigned_char
;
861 lai
->primitive_type_vector
[c_primitive_type_unsigned_short
] = builtin
->builtin_unsigned_short
;
862 lai
->primitive_type_vector
[c_primitive_type_unsigned_int
] = builtin
->builtin_unsigned_int
;
863 lai
->primitive_type_vector
[c_primitive_type_unsigned_long
] = builtin
->builtin_unsigned_long
;
864 lai
->primitive_type_vector
[c_primitive_type_unsigned_long_long
] = builtin
->builtin_unsigned_long_long
;
865 lai
->primitive_type_vector
[c_primitive_type_long_double
] = builtin
->builtin_long_double
;
866 lai
->primitive_type_vector
[c_primitive_type_complex
] = builtin
->builtin_complex
;
867 lai
->primitive_type_vector
[c_primitive_type_double_complex
] = builtin
->builtin_double_complex
;
868 lai
->primitive_type_vector
[c_primitive_type_decfloat
] = builtin
->builtin_decfloat
;
869 lai
->primitive_type_vector
[c_primitive_type_decdouble
] = builtin
->builtin_decdouble
;
870 lai
->primitive_type_vector
[c_primitive_type_declong
] = builtin
->builtin_declong
;
872 lai
->bool_type_default
= builtin
->builtin_int
;
875 const struct exp_descriptor exp_descriptor_c
=
877 print_subexp_standard
,
878 operator_length_standard
,
879 operator_check_standard
,
881 dump_subexp_body_standard
,
885 static const char *c_extensions
[] =
890 /* Constant data that describes the C language. */
892 extern const struct language_data c_language_data
=
894 "c", /* Language name */
905 c_printchar
, /* Print a character constant */
906 c_printstr
, /* Function to print string constant */
907 c_emit_char
, /* Print a single char */
908 c_print_typedef
, /* Print a typedef using appropriate syntax */
909 c_value_print_inner
, /* la_value_print_inner */
910 c_value_print
, /* Print a top-level value */
911 NULL
, /* name_of_this */
912 true, /* la_store_sym_names_in_linkage_form_p */
913 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
914 c_op_print_tab
, /* expression operators for printing */
915 1, /* c-style arrays */
916 0, /* String lower bound */
917 c_watch_location_expression
,
920 "{...}" /* la_struct_too_deep_ellipsis */
923 /* Class representing the C language. */
925 class c_language
: public language_defn
929 : language_defn (language_c
, c_language_data
)
932 /* See language.h. */
933 void language_arch_info (struct gdbarch
*gdbarch
,
934 struct language_arch_info
*lai
) const override
936 c_language_arch_info (gdbarch
, lai
);
939 /* See language.h. */
940 compile_instance
*get_compile_instance () const override
942 return c_get_compile_context ();
945 /* See language.h. */
946 std::string
compute_program (compile_instance
*inst
,
948 struct gdbarch
*gdbarch
,
949 const struct block
*expr_block
,
950 CORE_ADDR expr_pc
) const override
952 return c_compute_program (inst
, input
, gdbarch
, expr_block
, expr_pc
);
955 /* See language.h. */
957 void print_type (struct type
*type
, const char *varstring
,
958 struct ui_file
*stream
, int show
, int level
,
959 const struct type_print_options
*flags
) const override
961 c_print_type (type
, varstring
, stream
, show
, level
, flags
);
965 /* Single instance of the C language class. */
967 static c_language c_language_defn
;
969 enum cplus_primitive_types
{
970 cplus_primitive_type_int
,
971 cplus_primitive_type_long
,
972 cplus_primitive_type_short
,
973 cplus_primitive_type_char
,
974 cplus_primitive_type_float
,
975 cplus_primitive_type_double
,
976 cplus_primitive_type_void
,
977 cplus_primitive_type_long_long
,
978 cplus_primitive_type_signed_char
,
979 cplus_primitive_type_unsigned_char
,
980 cplus_primitive_type_unsigned_short
,
981 cplus_primitive_type_unsigned_int
,
982 cplus_primitive_type_unsigned_long
,
983 cplus_primitive_type_unsigned_long_long
,
984 cplus_primitive_type_long_double
,
985 cplus_primitive_type_complex
,
986 cplus_primitive_type_double_complex
,
987 cplus_primitive_type_bool
,
988 cplus_primitive_type_decfloat
,
989 cplus_primitive_type_decdouble
,
990 cplus_primitive_type_declong
,
991 cplus_primitive_type_char16_t
,
992 cplus_primitive_type_char32_t
,
993 cplus_primitive_type_wchar_t
,
994 nr_cplus_primitive_types
997 static const char *cplus_extensions
[] =
999 ".C", ".cc", ".cp", ".cpp", ".cxx", ".c++", NULL
1002 /* Constant data that describes the C++ language. */
1004 extern const struct language_data cplus_language_data
=
1006 "c++", /* Language name */
1017 c_printchar
, /* Print a character constant */
1018 c_printstr
, /* Function to print string constant */
1019 c_emit_char
, /* Print a single char */
1020 c_print_typedef
, /* Print a typedef using appropriate syntax */
1021 c_value_print_inner
, /* la_value_print_inner */
1022 c_value_print
, /* Print a top-level value */
1023 "this", /* name_of_this */
1024 false, /* la_store_sym_names_in_linkage_form_p */
1025 cp_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
1026 c_op_print_tab
, /* expression operators for printing */
1027 1, /* c-style arrays */
1028 0, /* String lower bound */
1029 c_watch_location_expression
,
1032 "{...}" /* la_struct_too_deep_ellipsis */
1035 /* A class for the C++ language. */
1037 class cplus_language
: public language_defn
1041 : language_defn (language_cplus
, cplus_language_data
)
1044 /* See language.h. */
1046 struct language_pass_by_ref_info pass_by_reference_info
1047 (struct type
*type
) const override
1049 return cp_pass_by_reference (type
);
1052 /* See language.h. */
1053 void language_arch_info (struct gdbarch
*gdbarch
,
1054 struct language_arch_info
*lai
) const override
1056 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
1058 lai
->string_char_type
= builtin
->builtin_char
;
1059 lai
->primitive_type_vector
1060 = GDBARCH_OBSTACK_CALLOC (gdbarch
, nr_cplus_primitive_types
+ 1,
1062 lai
->primitive_type_vector
[cplus_primitive_type_int
]
1063 = builtin
->builtin_int
;
1064 lai
->primitive_type_vector
[cplus_primitive_type_long
]
1065 = builtin
->builtin_long
;
1066 lai
->primitive_type_vector
[cplus_primitive_type_short
]
1067 = builtin
->builtin_short
;
1068 lai
->primitive_type_vector
[cplus_primitive_type_char
]
1069 = builtin
->builtin_char
;
1070 lai
->primitive_type_vector
[cplus_primitive_type_float
]
1071 = builtin
->builtin_float
;
1072 lai
->primitive_type_vector
[cplus_primitive_type_double
]
1073 = builtin
->builtin_double
;
1074 lai
->primitive_type_vector
[cplus_primitive_type_void
]
1075 = builtin
->builtin_void
;
1076 lai
->primitive_type_vector
[cplus_primitive_type_long_long
]
1077 = builtin
->builtin_long_long
;
1078 lai
->primitive_type_vector
[cplus_primitive_type_signed_char
]
1079 = builtin
->builtin_signed_char
;
1080 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_char
]
1081 = builtin
->builtin_unsigned_char
;
1082 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_short
]
1083 = builtin
->builtin_unsigned_short
;
1084 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_int
]
1085 = builtin
->builtin_unsigned_int
;
1086 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_long
]
1087 = builtin
->builtin_unsigned_long
;
1088 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_long_long
]
1089 = builtin
->builtin_unsigned_long_long
;
1090 lai
->primitive_type_vector
[cplus_primitive_type_long_double
]
1091 = builtin
->builtin_long_double
;
1092 lai
->primitive_type_vector
[cplus_primitive_type_complex
]
1093 = builtin
->builtin_complex
;
1094 lai
->primitive_type_vector
[cplus_primitive_type_double_complex
]
1095 = builtin
->builtin_double_complex
;
1096 lai
->primitive_type_vector
[cplus_primitive_type_bool
]
1097 = builtin
->builtin_bool
;
1098 lai
->primitive_type_vector
[cplus_primitive_type_decfloat
]
1099 = builtin
->builtin_decfloat
;
1100 lai
->primitive_type_vector
[cplus_primitive_type_decdouble
]
1101 = builtin
->builtin_decdouble
;
1102 lai
->primitive_type_vector
[cplus_primitive_type_declong
]
1103 = builtin
->builtin_declong
;
1104 lai
->primitive_type_vector
[cplus_primitive_type_char16_t
]
1105 = builtin
->builtin_char16
;
1106 lai
->primitive_type_vector
[cplus_primitive_type_char32_t
]
1107 = builtin
->builtin_char32
;
1108 lai
->primitive_type_vector
[cplus_primitive_type_wchar_t
]
1109 = builtin
->builtin_wchar
;
1111 lai
->bool_type_symbol
= "bool";
1112 lai
->bool_type_default
= builtin
->builtin_bool
;
1115 /* See language.h. */
1116 struct type
*lookup_transparent_type (const char *name
) const override
1118 return cp_lookup_transparent_type (name
);
1121 /* See language.h. */
1122 compile_instance
*get_compile_instance () const override
1124 return cplus_get_compile_context ();
1127 /* See language.h. */
1128 std::string
compute_program (compile_instance
*inst
,
1130 struct gdbarch
*gdbarch
,
1131 const struct block
*expr_block
,
1132 CORE_ADDR expr_pc
) const override
1134 return cplus_compute_program (inst
, input
, gdbarch
, expr_block
, expr_pc
);
1137 /* See language.h. */
1138 unsigned int search_name_hash (const char *name
) const override
1140 return cp_search_name_hash (name
);
1143 /* See language.h. */
1144 bool sniff_from_mangled_name (const char *mangled
,
1145 char **demangled
) const override
1147 *demangled
= gdb_demangle (mangled
, DMGL_PARAMS
| DMGL_ANSI
);
1148 return *demangled
!= NULL
;
1151 /* See language.h. */
1153 char *demangle (const char *mangled
, int options
) const override
1155 return gdb_demangle (mangled
, options
);
1158 /* See language.h. */
1160 void print_type (struct type
*type
, const char *varstring
,
1161 struct ui_file
*stream
, int show
, int level
,
1162 const struct type_print_options
*flags
) const override
1164 c_print_type (type
, varstring
, stream
, show
, level
, flags
);
1167 /* See language.h. */
1169 CORE_ADDR
skip_trampoline (struct frame_info
*fi
,
1170 CORE_ADDR pc
) const override
1172 return cplus_skip_trampoline (fi
, pc
);
1175 /* See language.h. */
1177 char *class_name_from_physname (const char *physname
) const override
1179 return cp_class_name_from_physname (physname
);
1184 /* See language.h. */
1186 symbol_name_matcher_ftype
*get_symbol_name_matcher_inner
1187 (const lookup_name_info
&lookup_name
) const override
1189 return cp_get_symbol_name_matcher (lookup_name
);
1193 /* The single instance of the C++ language class. */
1195 static cplus_language cplus_language_defn
;
1197 static const char *asm_extensions
[] =
1199 ".s", ".sx", ".S", NULL
1202 /* Constant data that describes the ASM language. */
1204 extern const struct language_data asm_language_data
=
1206 "asm", /* Language name */
1217 c_printchar
, /* Print a character constant */
1218 c_printstr
, /* Function to print string constant */
1219 c_emit_char
, /* Print a single char */
1220 c_print_typedef
, /* Print a typedef using appropriate syntax */
1221 c_value_print_inner
, /* la_value_print_inner */
1222 c_value_print
, /* Print a top-level value */
1223 NULL
, /* name_of_this */
1224 true, /* la_store_sym_names_in_linkage_form_p */
1225 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
1226 c_op_print_tab
, /* expression operators for printing */
1227 1, /* c-style arrays */
1228 0, /* String lower bound */
1229 c_watch_location_expression
,
1230 &default_varobj_ops
,
1232 "{...}" /* la_struct_too_deep_ellipsis */
1235 /* A class for the ASM language. */
1237 class asm_language
: public language_defn
1241 : language_defn (language_asm
, asm_language_data
)
1246 FIXME: Should this have its own arch info method? */
1247 void language_arch_info (struct gdbarch
*gdbarch
,
1248 struct language_arch_info
*lai
) const override
1250 c_language_arch_info (gdbarch
, lai
);
1253 /* See language.h. */
1255 void print_type (struct type
*type
, const char *varstring
,
1256 struct ui_file
*stream
, int show
, int level
,
1257 const struct type_print_options
*flags
) const override
1259 c_print_type (type
, varstring
, stream
, show
, level
, flags
);
1263 /* The single instance of the ASM language class. */
1264 static asm_language asm_language_defn
;
1266 /* The following language_defn does not represent a real language.
1267 It just provides a minimal support a-la-C that should allow users
1268 to do some simple operations when debugging applications that use
1269 a language currently not supported by GDB. */
1271 extern const struct language_data minimal_language_data
=
1273 "minimal", /* Language name */
1284 c_printchar
, /* Print a character constant */
1285 c_printstr
, /* Function to print string constant */
1286 c_emit_char
, /* Print a single char */
1287 c_print_typedef
, /* Print a typedef using appropriate syntax */
1288 c_value_print_inner
, /* la_value_print_inner */
1289 c_value_print
, /* Print a top-level value */
1290 NULL
, /* name_of_this */
1291 true, /* la_store_sym_names_in_linkage_form_p */
1292 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
1293 c_op_print_tab
, /* expression operators for printing */
1294 1, /* c-style arrays */
1295 0, /* String lower bound */
1296 c_watch_location_expression
,
1297 &default_varobj_ops
,
1299 "{...}" /* la_struct_too_deep_ellipsis */
1302 /* A class for the minimal language. */
1304 class minimal_language
: public language_defn
1308 : language_defn (language_minimal
, minimal_language_data
)
1311 /* See language.h. */
1312 void language_arch_info (struct gdbarch
*gdbarch
,
1313 struct language_arch_info
*lai
) const override
1315 c_language_arch_info (gdbarch
, lai
);
1318 /* See language.h. */
1320 void print_type (struct type
*type
, const char *varstring
,
1321 struct ui_file
*stream
, int show
, int level
,
1322 const struct type_print_options
*flags
) const override
1324 c_print_type (type
, varstring
, stream
, show
, level
, flags
);
1328 /* The single instance of the minimal language class. */
1329 static minimal_language minimal_language_defn
;