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 /* Given a C string type, STR_TYPE, return the corresponding target
41 character set name. */
44 charset_for_string_type (c_string_type str_type
, struct gdbarch
*gdbarch
)
46 switch (str_type
& ~C_CHAR
)
49 return target_charset (gdbarch
);
51 return target_wide_charset (gdbarch
);
53 /* FIXME: UTF-16 is not always correct. */
54 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
)
59 /* FIXME: UTF-32 is not always correct. */
60 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
)
65 internal_error (__FILE__
, __LINE__
, _("unhandled c_string_type"));
68 /* Classify ELTTYPE according to what kind of character it is. Return
69 the enum constant representing the character type. Also set
70 *ENCODING to the name of the character set to use when converting
71 characters of this type in target BYTE_ORDER to the host character
75 classify_type (struct type
*elttype
, struct gdbarch
*gdbarch
,
76 const char **encoding
)
80 /* We loop because ELTTYPE may be a typedef, and we want to
81 successively peel each typedef until we reach a type we
82 understand. We don't use CHECK_TYPEDEF because that will strip
83 all typedefs at once -- but in C, wchar_t is itself a typedef, so
84 that would do the wrong thing. */
87 const char *name
= elttype
->name ();
89 if (elttype
->code () == TYPE_CODE_CHAR
|| !name
)
95 if (!strcmp (name
, "wchar_t"))
101 if (!strcmp (name
, "char16_t"))
107 if (!strcmp (name
, "char32_t"))
113 if (elttype
->code () != TYPE_CODE_TYPEDEF
)
116 /* Call for side effects. */
117 check_typedef (elttype
);
119 if (TYPE_TARGET_TYPE (elttype
))
120 elttype
= TYPE_TARGET_TYPE (elttype
);
123 /* Perhaps check_typedef did not update the target type. In
124 this case, force the lookup again and hope it works out.
125 It never will for C, but it might for C++. */
126 elttype
= check_typedef (elttype
);
135 *encoding
= charset_for_string_type (result
, gdbarch
);
140 /* Print the character C on STREAM as part of the contents of a
141 literal string whose delimiter is QUOTER. Note that that format
142 for printing characters and strings is language specific. */
145 c_emit_char (int c
, struct type
*type
,
146 struct ui_file
*stream
, int quoter
)
148 const char *encoding
;
150 classify_type (type
, get_type_arch (type
), &encoding
);
151 generic_emit_char (c
, type
, stream
, quoter
, encoding
);
155 c_printchar (int c
, struct type
*type
, struct ui_file
*stream
)
157 c_string_type str_type
;
159 str_type
= classify_type (type
, get_type_arch (type
), NULL
);
165 fputc_filtered ('L', stream
);
168 fputc_filtered ('u', stream
);
171 fputc_filtered ('U', stream
);
175 fputc_filtered ('\'', stream
);
176 LA_EMIT_CHAR (c
, type
, stream
, '\'');
177 fputc_filtered ('\'', stream
);
180 /* Print the character string STRING, printing at most LENGTH
181 characters. LENGTH is -1 if the string is nul terminated. Each
182 character is WIDTH bytes long. Printing stops early if the number
183 hits print_max; repeat counts are printed as appropriate. Print
184 ellipses at the end if we had to stop before printing LENGTH
185 characters, or if FORCE_ELLIPSES. */
188 c_printstr (struct ui_file
*stream
, struct type
*type
,
189 const gdb_byte
*string
, unsigned int length
,
190 const char *user_encoding
, int force_ellipses
,
191 const struct value_print_options
*options
)
193 c_string_type str_type
;
194 const char *type_encoding
;
195 const char *encoding
;
197 str_type
= (classify_type (type
, get_type_arch (type
), &type_encoding
)
204 fputs_filtered ("L", stream
);
207 fputs_filtered ("u", stream
);
210 fputs_filtered ("U", stream
);
214 encoding
= (user_encoding
&& *user_encoding
) ? user_encoding
: type_encoding
;
216 generic_printstr (stream
, type
, string
, length
, encoding
, force_ellipses
,
220 /* Obtain a C string from the inferior storing it in a newly allocated
221 buffer in BUFFER, which should be freed by the caller. If the in-
222 and out-parameter *LENGTH is specified at -1, the string is read
223 until a null character of the appropriate width is found, otherwise
224 the string is read to the length of characters specified. The size
225 of a character is determined by the length of the target type of
226 the pointer or array.
228 If VALUE is an array with a known length, and *LENGTH is -1,
229 the function will not read past the end of the array. However, any
230 declared size of the array is ignored if *LENGTH > 0.
232 On completion, *LENGTH will be set to the size of the string read in
233 characters. (If a length of -1 is specified, the length returned
234 will not include the null character). CHARSET is always set to the
238 c_get_string (struct value
*value
, gdb::unique_xmalloc_ptr
<gdb_byte
> *buffer
,
239 int *length
, struct type
**char_type
,
240 const char **charset
)
243 unsigned int fetchlimit
;
244 struct type
*type
= check_typedef (value_type (value
));
245 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
246 int req_length
= *length
;
247 enum bfd_endian byte_order
248 = type_byte_order (type
);
250 if (element_type
== NULL
)
253 if (type
->code () == TYPE_CODE_ARRAY
)
255 /* If we know the size of the array, we can use it as a limit on
256 the number of characters to be fetched. */
257 if (type
->num_fields () == 1
258 && TYPE_FIELD_TYPE (type
, 0)->code () == TYPE_CODE_RANGE
)
260 LONGEST low_bound
, high_bound
;
262 get_discrete_bounds (TYPE_FIELD_TYPE (type
, 0),
263 &low_bound
, &high_bound
);
264 fetchlimit
= high_bound
- low_bound
+ 1;
267 fetchlimit
= UINT_MAX
;
269 else if (type
->code () == TYPE_CODE_PTR
)
270 fetchlimit
= UINT_MAX
;
272 /* We work only with arrays and pointers. */
275 if (! c_textual_element_type (element_type
, 0))
277 classify_type (element_type
, get_type_arch (element_type
), charset
);
278 width
= TYPE_LENGTH (element_type
);
280 /* If the string lives in GDB's memory instead of the inferior's,
281 then we just need to copy it to BUFFER. Also, since such strings
282 are arrays with known size, FETCHLIMIT will hold the size of the
285 An array is assumed to live in GDB's memory, so we take this path
288 However, it's possible for the caller to request more array
289 elements than apparently exist -- this can happen when using the
290 C struct hack. So, only do this if either no length was
291 specified, or the length is within the existing bounds. This
292 avoids running off the end of the value's contents. */
293 if ((VALUE_LVAL (value
) == not_lval
294 || VALUE_LVAL (value
) == lval_internalvar
295 || type
->code () == TYPE_CODE_ARRAY
)
296 && fetchlimit
!= UINT_MAX
297 && (*length
< 0 || *length
<= fetchlimit
))
300 const gdb_byte
*contents
= value_contents (value
);
302 /* If a length is specified, use that. */
306 /* Otherwise, look for a null character. */
307 for (i
= 0; i
< fetchlimit
; i
++)
308 if (extract_unsigned_integer (contents
+ i
* width
,
309 width
, byte_order
) == 0)
312 /* I is now either a user-defined length, the number of non-null
313 characters, or FETCHLIMIT. */
315 buffer
->reset ((gdb_byte
*) xmalloc (*length
));
316 memcpy (buffer
->get (), contents
, *length
);
321 /* value_as_address does not return an address for an array when
322 c_style_arrays is false, so we handle that specially
325 if (type
->code () == TYPE_CODE_ARRAY
)
327 if (VALUE_LVAL (value
) != lval_memory
)
328 error (_("Attempt to take address of value "
329 "not located in memory."));
330 addr
= value_address (value
);
333 addr
= value_as_address (value
);
335 /* Prior to the fix for PR 16196 read_string would ignore fetchlimit
336 if length > 0. The old "broken" behaviour is the behaviour we want:
337 The caller may want to fetch 100 bytes from a variable length array
338 implemented using the common idiom of having an array of length 1 at
339 the end of a struct. In this case we want to ignore the declared
340 size of the array. However, it's counterintuitive to implement that
341 behaviour in read_string: what does fetchlimit otherwise mean if
342 length > 0. Therefore we implement the behaviour we want here:
343 If *length > 0, don't specify a fetchlimit. This preserves the
344 previous behaviour. We could move this check above where we know
345 whether the array is declared with a fixed size, but we only want
346 to apply this behaviour when calling read_string. PR 16286. */
348 fetchlimit
= UINT_MAX
;
350 err
= read_string (addr
, *length
, width
, fetchlimit
,
351 byte_order
, buffer
, length
);
353 memory_error (TARGET_XFER_E_IO
, addr
);
356 /* If the LENGTH is specified at -1, we want to return the string
357 length up to the terminating null character. If an actual length
358 was specified, we want to return the length of exactly what was
360 if (req_length
== -1)
361 /* If the last character is null, subtract it from LENGTH. */
363 && extract_unsigned_integer (buffer
->get () + *length
- width
,
364 width
, byte_order
) == 0)
367 /* The read_string function will return the number of bytes read.
368 If length returned from read_string was > 0, return the number of
369 characters read by dividing the number of bytes by width. */
371 *length
= *length
/ width
;
373 *char_type
= element_type
;
379 std::string type_str
= type_to_string (type
);
380 if (!type_str
.empty ())
382 error (_("Trying to read string with inappropriate type `%s'."),
386 error (_("Trying to read string with inappropriate type."));
391 /* Evaluating C and C++ expressions. */
393 /* Convert a UCN. The digits of the UCN start at P and extend no
394 farther than LIMIT. DEST_CHARSET is the name of the character set
395 into which the UCN should be converted. The results are written to
396 OUTPUT. LENGTH is the maximum length of the UCN, either 4 or 8.
397 Returns a pointer to just after the final digit of the UCN. */
400 convert_ucn (char *p
, char *limit
, const char *dest_charset
,
401 struct obstack
*output
, int length
)
403 unsigned long result
= 0;
407 for (i
= 0; i
< length
&& p
< limit
&& ISXDIGIT (*p
); ++i
, ++p
)
408 result
= (result
<< 4) + host_hex_value (*p
);
410 for (i
= 3; i
>= 0; --i
)
412 data
[i
] = result
& 0xff;
416 convert_between_encodings ("UTF-32BE", dest_charset
, data
,
417 4, 4, output
, translit_none
);
422 /* Emit a character, VALUE, which was specified numerically, to
423 OUTPUT. TYPE is the target character type. */
426 emit_numeric_character (struct type
*type
, unsigned long value
,
427 struct obstack
*output
)
431 buffer
= (gdb_byte
*) alloca (TYPE_LENGTH (type
));
432 pack_long (buffer
, type
, value
);
433 obstack_grow (output
, buffer
, TYPE_LENGTH (type
));
436 /* Convert an octal escape sequence. TYPE is the target character
437 type. The digits of the escape sequence begin at P and extend no
438 farther than LIMIT. The result is written to OUTPUT. Returns a
439 pointer to just after the final digit of the escape sequence. */
442 convert_octal (struct type
*type
, char *p
,
443 char *limit
, struct obstack
*output
)
446 unsigned long value
= 0;
449 i
< 3 && p
< limit
&& ISDIGIT (*p
) && *p
!= '8' && *p
!= '9';
452 value
= 8 * value
+ host_hex_value (*p
);
456 emit_numeric_character (type
, value
, output
);
461 /* Convert a hex escape sequence. TYPE is the target character type.
462 The digits of the escape sequence begin at P and extend no farther
463 than LIMIT. The result is written to OUTPUT. Returns a pointer to
464 just after the final digit of the escape sequence. */
467 convert_hex (struct type
*type
, char *p
,
468 char *limit
, struct obstack
*output
)
470 unsigned long value
= 0;
472 while (p
< limit
&& ISXDIGIT (*p
))
474 value
= 16 * value
+ host_hex_value (*p
);
478 emit_numeric_character (type
, value
, output
);
487 error (_("Malformed escape sequence")); \
490 /* Convert an escape sequence to a target format. TYPE is the target
491 character type to use, and DEST_CHARSET is the name of the target
492 character set. The backslash of the escape sequence is at *P, and
493 the escape sequence will not extend past LIMIT. The results are
494 written to OUTPUT. Returns a pointer to just past the final
495 character of the escape sequence. */
498 convert_escape (struct type
*type
, const char *dest_charset
,
499 char *p
, char *limit
, struct obstack
*output
)
501 /* Skip the backslash. */
507 obstack_1grow (output
, '\\');
514 error (_("\\x used with no following hex digits."));
515 p
= convert_hex (type
, p
, limit
, output
);
526 p
= convert_octal (type
, p
, limit
, output
);
532 int length
= *p
== 'u' ? 4 : 8;
536 error (_("\\u used with no following hex digits"));
537 p
= convert_ucn (p
, limit
, dest_charset
, output
, length
);
544 /* Given a single string from a (C-specific) OP_STRING list, convert
545 it to a target string, handling escape sequences specially. The
546 output is written to OUTPUT. DATA is the input string, which has
547 length LEN. DEST_CHARSET is the name of the target character set,
548 and TYPE is the type of target character to use. */
551 parse_one_string (struct obstack
*output
, char *data
, int len
,
552 const char *dest_charset
, struct type
*type
)
562 /* Look for next escape, or the end of the input. */
563 while (p
< limit
&& *p
!= '\\')
565 /* If we saw a run of characters, convert them all. */
567 convert_between_encodings (host_charset (), dest_charset
,
568 (gdb_byte
*) data
, p
- data
, 1,
569 output
, translit_none
);
570 /* If we saw an escape, convert it. */
572 p
= convert_escape (type
, dest_charset
, p
, limit
, output
);
577 /* Expression evaluator for the C language family. Most operations
578 are delegated to evaluate_subexp_standard; see that function for a
579 description of the arguments. */
582 evaluate_subexp_c (struct type
*expect_type
, struct expression
*exp
,
583 int *pos
, enum noside noside
)
585 enum exp_opcode op
= exp
->elts
[*pos
].opcode
;
593 struct value
*result
;
594 c_string_type dest_type
;
595 const char *dest_charset
;
596 int satisfy_expected
= 0;
601 oplen
= longest_to_int (exp
->elts
[*pos
].longconst
);
604 limit
= *pos
+ BYTES_TO_EXP_ELEM (oplen
+ 1);
605 dest_type
= ((enum c_string_type_values
)
606 longest_to_int (exp
->elts
[*pos
].longconst
));
607 switch (dest_type
& ~C_CHAR
)
610 type
= language_string_char_type (exp
->language_defn
,
614 type
= lookup_typename (exp
->language_defn
, "wchar_t", NULL
, 0);
617 type
= lookup_typename (exp
->language_defn
, "char16_t", NULL
, 0);
620 type
= lookup_typename (exp
->language_defn
, "char32_t", NULL
, 0);
623 internal_error (__FILE__
, __LINE__
, _("unhandled c_string_type"));
626 /* Ensure TYPE_LENGTH is valid for TYPE. */
627 check_typedef (type
);
629 /* If the caller expects an array of some integral type,
630 satisfy them. If something odder is expected, rely on the
632 if (expect_type
&& expect_type
->code () == TYPE_CODE_ARRAY
)
634 struct type
*element_type
635 = check_typedef (TYPE_TARGET_TYPE (expect_type
));
637 if (element_type
->code () == TYPE_CODE_INT
638 || element_type
->code () == TYPE_CODE_CHAR
)
641 satisfy_expected
= 1;
645 dest_charset
= charset_for_string_type (dest_type
, exp
->gdbarch
);
652 len
= longest_to_int (exp
->elts
[*pos
].longconst
);
655 if (noside
!= EVAL_SKIP
)
656 parse_one_string (&output
, &exp
->elts
[*pos
].string
, len
,
658 *pos
+= BYTES_TO_EXP_ELEM (len
);
661 /* Skip the trailing length and opcode. */
664 if (noside
== EVAL_SKIP
)
666 /* Return a dummy value of the appropriate type. */
667 if (expect_type
!= NULL
)
668 result
= allocate_value (expect_type
);
669 else if ((dest_type
& C_CHAR
) != 0)
670 result
= allocate_value (type
);
672 result
= value_cstring ("", 0, type
);
676 if ((dest_type
& C_CHAR
) != 0)
680 if (obstack_object_size (&output
) != TYPE_LENGTH (type
))
681 error (_("Could not convert character "
682 "constant to target character set"));
683 value
= unpack_long (type
, (gdb_byte
*) obstack_base (&output
));
684 result
= value_from_longest (type
, value
);
690 /* Write the terminating character. */
691 for (i
= 0; i
< TYPE_LENGTH (type
); ++i
)
692 obstack_1grow (&output
, 0);
694 if (satisfy_expected
)
696 LONGEST low_bound
, high_bound
;
697 int element_size
= TYPE_LENGTH (type
);
699 if (get_discrete_bounds (TYPE_INDEX_TYPE (expect_type
),
700 &low_bound
, &high_bound
) < 0)
703 high_bound
= (TYPE_LENGTH (expect_type
) / element_size
) - 1;
705 if (obstack_object_size (&output
) / element_size
706 > (high_bound
- low_bound
+ 1))
707 error (_("Too many array elements"));
709 result
= allocate_value (expect_type
);
710 memcpy (value_contents_raw (result
), obstack_base (&output
),
711 obstack_object_size (&output
));
714 result
= value_cstring ((const char *) obstack_base (&output
),
715 obstack_object_size (&output
),
725 return evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
728 /* la_watch_location_expression for C. */
730 gdb::unique_xmalloc_ptr
<char>
731 c_watch_location_expression (struct type
*type
, CORE_ADDR addr
)
733 type
= check_typedef (TYPE_TARGET_TYPE (check_typedef (type
)));
734 std::string name
= type_to_string (type
);
735 return gdb::unique_xmalloc_ptr
<char>
736 (xstrprintf ("* (%s *) %s", name
.c_str (), core_addr_to_string (addr
)));
742 c_is_string_type_p (struct type
*type
)
744 type
= check_typedef (type
);
745 while (type
->code () == TYPE_CODE_REF
)
747 type
= TYPE_TARGET_TYPE (type
);
748 type
= check_typedef (type
);
751 switch (type
->code ())
753 case TYPE_CODE_ARRAY
:
755 /* See if target type looks like a string. */
756 struct type
*array_target_type
= TYPE_TARGET_TYPE (type
);
757 return (TYPE_LENGTH (type
) > 0
758 && TYPE_LENGTH (array_target_type
) > 0
759 && c_textual_element_type (array_target_type
, 0));
761 case TYPE_CODE_STRING
:
765 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
766 return c_textual_element_type (element_type
, 0);
776 /* Table mapping opcodes into strings for printing operators
777 and precedences of the operators. */
779 const struct op_print c_op_print_tab
[] =
781 {",", BINOP_COMMA
, PREC_COMMA
, 0},
782 {"=", BINOP_ASSIGN
, PREC_ASSIGN
, 1},
783 {"||", BINOP_LOGICAL_OR
, PREC_LOGICAL_OR
, 0},
784 {"&&", BINOP_LOGICAL_AND
, PREC_LOGICAL_AND
, 0},
785 {"|", BINOP_BITWISE_IOR
, PREC_BITWISE_IOR
, 0},
786 {"^", BINOP_BITWISE_XOR
, PREC_BITWISE_XOR
, 0},
787 {"&", BINOP_BITWISE_AND
, PREC_BITWISE_AND
, 0},
788 {"==", BINOP_EQUAL
, PREC_EQUAL
, 0},
789 {"!=", BINOP_NOTEQUAL
, PREC_EQUAL
, 0},
790 {"<=", BINOP_LEQ
, PREC_ORDER
, 0},
791 {">=", BINOP_GEQ
, PREC_ORDER
, 0},
792 {">", BINOP_GTR
, PREC_ORDER
, 0},
793 {"<", BINOP_LESS
, PREC_ORDER
, 0},
794 {">>", BINOP_RSH
, PREC_SHIFT
, 0},
795 {"<<", BINOP_LSH
, PREC_SHIFT
, 0},
796 {"+", BINOP_ADD
, PREC_ADD
, 0},
797 {"-", BINOP_SUB
, PREC_ADD
, 0},
798 {"*", BINOP_MUL
, PREC_MUL
, 0},
799 {"/", BINOP_DIV
, PREC_MUL
, 0},
800 {"%", BINOP_REM
, PREC_MUL
, 0},
801 {"@", BINOP_REPEAT
, PREC_REPEAT
, 0},
802 {"+", UNOP_PLUS
, PREC_PREFIX
, 0},
803 {"-", UNOP_NEG
, PREC_PREFIX
, 0},
804 {"!", UNOP_LOGICAL_NOT
, PREC_PREFIX
, 0},
805 {"~", UNOP_COMPLEMENT
, PREC_PREFIX
, 0},
806 {"*", UNOP_IND
, PREC_PREFIX
, 0},
807 {"&", UNOP_ADDR
, PREC_PREFIX
, 0},
808 {"sizeof ", UNOP_SIZEOF
, PREC_PREFIX
, 0},
809 {"alignof ", UNOP_ALIGNOF
, PREC_PREFIX
, 0},
810 {"++", UNOP_PREINCREMENT
, PREC_PREFIX
, 0},
811 {"--", UNOP_PREDECREMENT
, PREC_PREFIX
, 0},
812 {NULL
, OP_NULL
, PREC_PREFIX
, 0}
815 enum c_primitive_types
{
816 c_primitive_type_int
,
817 c_primitive_type_long
,
818 c_primitive_type_short
,
819 c_primitive_type_char
,
820 c_primitive_type_float
,
821 c_primitive_type_double
,
822 c_primitive_type_void
,
823 c_primitive_type_long_long
,
824 c_primitive_type_signed_char
,
825 c_primitive_type_unsigned_char
,
826 c_primitive_type_unsigned_short
,
827 c_primitive_type_unsigned_int
,
828 c_primitive_type_unsigned_long
,
829 c_primitive_type_unsigned_long_long
,
830 c_primitive_type_long_double
,
831 c_primitive_type_complex
,
832 c_primitive_type_double_complex
,
833 c_primitive_type_decfloat
,
834 c_primitive_type_decdouble
,
835 c_primitive_type_declong
,
840 c_language_arch_info (struct gdbarch
*gdbarch
,
841 struct language_arch_info
*lai
)
843 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
845 lai
->string_char_type
= builtin
->builtin_char
;
846 lai
->primitive_type_vector
847 = GDBARCH_OBSTACK_CALLOC (gdbarch
, nr_c_primitive_types
+ 1,
849 lai
->primitive_type_vector
[c_primitive_type_int
] = builtin
->builtin_int
;
850 lai
->primitive_type_vector
[c_primitive_type_long
] = builtin
->builtin_long
;
851 lai
->primitive_type_vector
[c_primitive_type_short
] = builtin
->builtin_short
;
852 lai
->primitive_type_vector
[c_primitive_type_char
] = builtin
->builtin_char
;
853 lai
->primitive_type_vector
[c_primitive_type_float
] = builtin
->builtin_float
;
854 lai
->primitive_type_vector
[c_primitive_type_double
] = builtin
->builtin_double
;
855 lai
->primitive_type_vector
[c_primitive_type_void
] = builtin
->builtin_void
;
856 lai
->primitive_type_vector
[c_primitive_type_long_long
] = builtin
->builtin_long_long
;
857 lai
->primitive_type_vector
[c_primitive_type_signed_char
] = builtin
->builtin_signed_char
;
858 lai
->primitive_type_vector
[c_primitive_type_unsigned_char
] = builtin
->builtin_unsigned_char
;
859 lai
->primitive_type_vector
[c_primitive_type_unsigned_short
] = builtin
->builtin_unsigned_short
;
860 lai
->primitive_type_vector
[c_primitive_type_unsigned_int
] = builtin
->builtin_unsigned_int
;
861 lai
->primitive_type_vector
[c_primitive_type_unsigned_long
] = builtin
->builtin_unsigned_long
;
862 lai
->primitive_type_vector
[c_primitive_type_unsigned_long_long
] = builtin
->builtin_unsigned_long_long
;
863 lai
->primitive_type_vector
[c_primitive_type_long_double
] = builtin
->builtin_long_double
;
864 lai
->primitive_type_vector
[c_primitive_type_complex
] = builtin
->builtin_complex
;
865 lai
->primitive_type_vector
[c_primitive_type_double_complex
] = builtin
->builtin_double_complex
;
866 lai
->primitive_type_vector
[c_primitive_type_decfloat
] = builtin
->builtin_decfloat
;
867 lai
->primitive_type_vector
[c_primitive_type_decdouble
] = builtin
->builtin_decdouble
;
868 lai
->primitive_type_vector
[c_primitive_type_declong
] = builtin
->builtin_declong
;
870 lai
->bool_type_default
= builtin
->builtin_int
;
873 const struct exp_descriptor exp_descriptor_c
=
875 print_subexp_standard
,
876 operator_length_standard
,
877 operator_check_standard
,
879 dump_subexp_body_standard
,
883 static const char *c_extensions
[] =
888 /* Constant data that describes the C language. */
890 extern const struct language_data c_language_data
=
892 "c", /* Language name */
903 c_printchar
, /* Print a character constant */
904 c_printstr
, /* Function to print string constant */
905 c_emit_char
, /* Print a single char */
906 c_print_type
, /* Print a type using appropriate syntax */
907 c_print_typedef
, /* Print a typedef using appropriate syntax */
908 c_value_print_inner
, /* la_value_print_inner */
909 c_value_print
, /* Print a top-level value */
910 default_read_var_value
, /* la_read_var_value */
911 NULL
, /* Language specific skip_trampoline */
912 NULL
, /* name_of_this */
913 true, /* la_store_sym_names_in_linkage_form_p */
914 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
915 basic_lookup_transparent_type
,/* lookup_transparent_type */
916 NULL
, /* Language specific symbol demangler */
918 NULL
, /* Language specific
919 class_name_from_physname */
920 c_op_print_tab
, /* expression operators for printing */
921 1, /* c-style arrays */
922 0, /* String lower bound */
923 default_word_break_characters
,
924 default_collect_symbol_completion_matches
,
925 c_language_arch_info
,
926 default_print_array_index
,
927 default_pass_by_reference
,
928 c_watch_location_expression
,
929 NULL
, /* la_get_symbol_name_matcher */
930 iterate_over_symbols
,
931 default_search_name_hash
,
933 c_get_compile_context
,
936 "{...}" /* la_struct_too_deep_ellipsis */
939 /* Class representing the C language. */
941 class c_language
: public language_defn
945 : language_defn (language_c
, c_language_data
)
949 /* Single instance of the C language class. */
951 static c_language c_language_defn
;
953 enum cplus_primitive_types
{
954 cplus_primitive_type_int
,
955 cplus_primitive_type_long
,
956 cplus_primitive_type_short
,
957 cplus_primitive_type_char
,
958 cplus_primitive_type_float
,
959 cplus_primitive_type_double
,
960 cplus_primitive_type_void
,
961 cplus_primitive_type_long_long
,
962 cplus_primitive_type_signed_char
,
963 cplus_primitive_type_unsigned_char
,
964 cplus_primitive_type_unsigned_short
,
965 cplus_primitive_type_unsigned_int
,
966 cplus_primitive_type_unsigned_long
,
967 cplus_primitive_type_unsigned_long_long
,
968 cplus_primitive_type_long_double
,
969 cplus_primitive_type_complex
,
970 cplus_primitive_type_double_complex
,
971 cplus_primitive_type_bool
,
972 cplus_primitive_type_decfloat
,
973 cplus_primitive_type_decdouble
,
974 cplus_primitive_type_declong
,
975 cplus_primitive_type_char16_t
,
976 cplus_primitive_type_char32_t
,
977 cplus_primitive_type_wchar_t
,
978 nr_cplus_primitive_types
982 cplus_language_arch_info (struct gdbarch
*gdbarch
,
983 struct language_arch_info
*lai
)
985 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
987 lai
->string_char_type
= builtin
->builtin_char
;
988 lai
->primitive_type_vector
989 = GDBARCH_OBSTACK_CALLOC (gdbarch
, nr_cplus_primitive_types
+ 1,
991 lai
->primitive_type_vector
[cplus_primitive_type_int
]
992 = builtin
->builtin_int
;
993 lai
->primitive_type_vector
[cplus_primitive_type_long
]
994 = builtin
->builtin_long
;
995 lai
->primitive_type_vector
[cplus_primitive_type_short
]
996 = builtin
->builtin_short
;
997 lai
->primitive_type_vector
[cplus_primitive_type_char
]
998 = builtin
->builtin_char
;
999 lai
->primitive_type_vector
[cplus_primitive_type_float
]
1000 = builtin
->builtin_float
;
1001 lai
->primitive_type_vector
[cplus_primitive_type_double
]
1002 = builtin
->builtin_double
;
1003 lai
->primitive_type_vector
[cplus_primitive_type_void
]
1004 = builtin
->builtin_void
;
1005 lai
->primitive_type_vector
[cplus_primitive_type_long_long
]
1006 = builtin
->builtin_long_long
;
1007 lai
->primitive_type_vector
[cplus_primitive_type_signed_char
]
1008 = builtin
->builtin_signed_char
;
1009 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_char
]
1010 = builtin
->builtin_unsigned_char
;
1011 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_short
]
1012 = builtin
->builtin_unsigned_short
;
1013 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_int
]
1014 = builtin
->builtin_unsigned_int
;
1015 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_long
]
1016 = builtin
->builtin_unsigned_long
;
1017 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_long_long
]
1018 = builtin
->builtin_unsigned_long_long
;
1019 lai
->primitive_type_vector
[cplus_primitive_type_long_double
]
1020 = builtin
->builtin_long_double
;
1021 lai
->primitive_type_vector
[cplus_primitive_type_complex
]
1022 = builtin
->builtin_complex
;
1023 lai
->primitive_type_vector
[cplus_primitive_type_double_complex
]
1024 = builtin
->builtin_double_complex
;
1025 lai
->primitive_type_vector
[cplus_primitive_type_bool
]
1026 = builtin
->builtin_bool
;
1027 lai
->primitive_type_vector
[cplus_primitive_type_decfloat
]
1028 = builtin
->builtin_decfloat
;
1029 lai
->primitive_type_vector
[cplus_primitive_type_decdouble
]
1030 = builtin
->builtin_decdouble
;
1031 lai
->primitive_type_vector
[cplus_primitive_type_declong
]
1032 = builtin
->builtin_declong
;
1033 lai
->primitive_type_vector
[cplus_primitive_type_char16_t
]
1034 = builtin
->builtin_char16
;
1035 lai
->primitive_type_vector
[cplus_primitive_type_char32_t
]
1036 = builtin
->builtin_char32
;
1037 lai
->primitive_type_vector
[cplus_primitive_type_wchar_t
]
1038 = builtin
->builtin_wchar
;
1040 lai
->bool_type_symbol
= "bool";
1041 lai
->bool_type_default
= builtin
->builtin_bool
;
1044 static const char *cplus_extensions
[] =
1046 ".C", ".cc", ".cp", ".cpp", ".cxx", ".c++", NULL
1049 /* Constant data that describes the C++ language. */
1051 extern const struct language_data cplus_language_data
=
1053 "c++", /* Language name */
1064 c_printchar
, /* Print a character constant */
1065 c_printstr
, /* Function to print string constant */
1066 c_emit_char
, /* Print a single char */
1067 c_print_type
, /* Print a type using appropriate syntax */
1068 c_print_typedef
, /* Print a typedef using appropriate syntax */
1069 c_value_print_inner
, /* la_value_print_inner */
1070 c_value_print
, /* Print a top-level value */
1071 default_read_var_value
, /* la_read_var_value */
1072 cplus_skip_trampoline
, /* Language specific skip_trampoline */
1073 "this", /* name_of_this */
1074 false, /* la_store_sym_names_in_linkage_form_p */
1075 cp_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
1076 cp_lookup_transparent_type
, /* lookup_transparent_type */
1077 gdb_demangle
, /* Language specific symbol demangler */
1078 gdb_sniff_from_mangled_name
,
1079 cp_class_name_from_physname
, /* Language specific
1080 class_name_from_physname */
1081 c_op_print_tab
, /* expression operators for printing */
1082 1, /* c-style arrays */
1083 0, /* String lower bound */
1084 default_word_break_characters
,
1085 default_collect_symbol_completion_matches
,
1086 cplus_language_arch_info
,
1087 default_print_array_index
,
1088 cp_pass_by_reference
,
1089 c_watch_location_expression
,
1090 cp_get_symbol_name_matcher
,
1091 iterate_over_symbols
,
1092 cp_search_name_hash
,
1094 cplus_get_compile_context
,
1095 cplus_compute_program
,
1097 "{...}" /* la_struct_too_deep_ellipsis */
1100 /* A class for the C++ language. */
1102 class cplus_language
: public language_defn
1106 : language_defn (language_cplus
, cplus_language_data
)
1110 /* The single instance of the C++ language class. */
1112 static cplus_language cplus_language_defn
;
1114 static const char *asm_extensions
[] =
1116 ".s", ".sx", ".S", NULL
1119 /* Constant data that describes the ASM language. */
1121 extern const struct language_data asm_language_data
=
1123 "asm", /* Language name */
1134 c_printchar
, /* Print a character constant */
1135 c_printstr
, /* Function to print string constant */
1136 c_emit_char
, /* Print a single char */
1137 c_print_type
, /* Print a type using appropriate syntax */
1138 c_print_typedef
, /* Print a typedef using appropriate syntax */
1139 c_value_print_inner
, /* la_value_print_inner */
1140 c_value_print
, /* Print a top-level value */
1141 default_read_var_value
, /* la_read_var_value */
1142 NULL
, /* Language specific skip_trampoline */
1143 NULL
, /* name_of_this */
1144 true, /* la_store_sym_names_in_linkage_form_p */
1145 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
1146 basic_lookup_transparent_type
,/* lookup_transparent_type */
1147 NULL
, /* Language specific symbol demangler */
1149 NULL
, /* Language specific
1150 class_name_from_physname */
1151 c_op_print_tab
, /* expression operators for printing */
1152 1, /* c-style arrays */
1153 0, /* String lower bound */
1154 default_word_break_characters
,
1155 default_collect_symbol_completion_matches
,
1156 c_language_arch_info
, /* FIXME: la_language_arch_info. */
1157 default_print_array_index
,
1158 default_pass_by_reference
,
1159 c_watch_location_expression
,
1160 NULL
, /* la_get_symbol_name_matcher */
1161 iterate_over_symbols
,
1162 default_search_name_hash
,
1163 &default_varobj_ops
,
1167 "{...}" /* la_struct_too_deep_ellipsis */
1170 /* A class for the ASM language. */
1172 class asm_language
: public language_defn
1176 : language_defn (language_asm
, asm_language_data
)
1180 /* The single instance of the ASM language class. */
1181 static asm_language asm_language_defn
;
1183 /* The following language_defn does not represent a real language.
1184 It just provides a minimal support a-la-C that should allow users
1185 to do some simple operations when debugging applications that use
1186 a language currently not supported by GDB. */
1188 extern const struct language_data minimal_language_data
=
1190 "minimal", /* Language name */
1201 c_printchar
, /* Print a character constant */
1202 c_printstr
, /* Function to print string constant */
1203 c_emit_char
, /* Print a single char */
1204 c_print_type
, /* Print a type using appropriate syntax */
1205 c_print_typedef
, /* Print a typedef using appropriate syntax */
1206 c_value_print_inner
, /* la_value_print_inner */
1207 c_value_print
, /* Print a top-level value */
1208 default_read_var_value
, /* la_read_var_value */
1209 NULL
, /* Language specific skip_trampoline */
1210 NULL
, /* name_of_this */
1211 true, /* la_store_sym_names_in_linkage_form_p */
1212 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
1213 basic_lookup_transparent_type
,/* lookup_transparent_type */
1214 NULL
, /* Language specific symbol demangler */
1216 NULL
, /* Language specific
1217 class_name_from_physname */
1218 c_op_print_tab
, /* expression operators for printing */
1219 1, /* c-style arrays */
1220 0, /* String lower bound */
1221 default_word_break_characters
,
1222 default_collect_symbol_completion_matches
,
1223 c_language_arch_info
,
1224 default_print_array_index
,
1225 default_pass_by_reference
,
1226 c_watch_location_expression
,
1227 NULL
, /* la_get_symbol_name_matcher */
1228 iterate_over_symbols
,
1229 default_search_name_hash
,
1230 &default_varobj_ops
,
1234 "{...}" /* la_struct_too_deep_ellipsis */
1237 /* A class for the minimal language. */
1239 class minimal_language
: public language_defn
1243 : language_defn (language_minimal
, minimal_language_data
)
1247 /* The single instance of the minimal language class. */
1248 static minimal_language minimal_language_defn
;