1 /* C language support routines for GDB, the GNU debugger.
3 Copyright (C) 1992-2019 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/>. */
22 /* Standard C includes. */
25 /* Local non-gdb includes. */
27 #include "c-support.h"
30 #include "cp-support.h"
32 #include "expression.h"
33 #include "gdb_obstack.h"
37 #include "macroscope.h"
38 #include "parser-defs.h"
43 /* Given a C string type, STR_TYPE, return the corresponding target
44 character set name. */
47 charset_for_string_type (c_string_type str_type
, struct gdbarch
*gdbarch
)
49 switch (str_type
& ~C_CHAR
)
52 return target_charset (gdbarch
);
54 return target_wide_charset (gdbarch
);
56 /* FIXME: UTF-16 is not always correct. */
57 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
)
62 /* FIXME: UTF-32 is not always correct. */
63 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
)
68 internal_error (__FILE__
, __LINE__
, _("unhandled c_string_type"));
71 /* Classify ELTTYPE according to what kind of character it is. Return
72 the enum constant representing the character type. Also set
73 *ENCODING to the name of the character set to use when converting
74 characters of this type in target BYTE_ORDER to the host character
78 classify_type (struct type
*elttype
, struct gdbarch
*gdbarch
,
79 const char **encoding
)
83 /* We loop because ELTTYPE may be a typedef, and we want to
84 successively peel each typedef until we reach a type we
85 understand. We don't use CHECK_TYPEDEF because that will strip
86 all typedefs at once -- but in C, wchar_t is itself a typedef, so
87 that would do the wrong thing. */
90 const char *name
= TYPE_NAME (elttype
);
92 if (TYPE_CODE (elttype
) == TYPE_CODE_CHAR
|| !name
)
98 if (!strcmp (name
, "wchar_t"))
100 result
= C_WIDE_CHAR
;
104 if (!strcmp (name
, "char16_t"))
110 if (!strcmp (name
, "char32_t"))
116 if (TYPE_CODE (elttype
) != TYPE_CODE_TYPEDEF
)
119 /* Call for side effects. */
120 check_typedef (elttype
);
122 if (TYPE_TARGET_TYPE (elttype
))
123 elttype
= TYPE_TARGET_TYPE (elttype
);
126 /* Perhaps check_typedef did not update the target type. In
127 this case, force the lookup again and hope it works out.
128 It never will for C, but it might for C++. */
129 elttype
= check_typedef (elttype
);
138 *encoding
= charset_for_string_type (result
, gdbarch
);
143 /* Print the character C on STREAM as part of the contents of a
144 literal string whose delimiter is QUOTER. Note that that format
145 for printing characters and strings is language specific. */
148 c_emit_char (int c
, struct type
*type
,
149 struct ui_file
*stream
, int quoter
)
151 const char *encoding
;
153 classify_type (type
, get_type_arch (type
), &encoding
);
154 generic_emit_char (c
, type
, stream
, quoter
, encoding
);
158 c_printchar (int c
, struct type
*type
, struct ui_file
*stream
)
160 c_string_type str_type
;
162 str_type
= classify_type (type
, get_type_arch (type
), NULL
);
168 fputc_filtered ('L', stream
);
171 fputc_filtered ('u', stream
);
174 fputc_filtered ('U', stream
);
178 fputc_filtered ('\'', stream
);
179 LA_EMIT_CHAR (c
, type
, stream
, '\'');
180 fputc_filtered ('\'', stream
);
183 /* Print the character string STRING, printing at most LENGTH
184 characters. LENGTH is -1 if the string is nul terminated. Each
185 character is WIDTH bytes long. Printing stops early if the number
186 hits print_max; repeat counts are printed as appropriate. Print
187 ellipses at the end if we had to stop before printing LENGTH
188 characters, or if FORCE_ELLIPSES. */
191 c_printstr (struct ui_file
*stream
, struct type
*type
,
192 const gdb_byte
*string
, unsigned int length
,
193 const char *user_encoding
, int force_ellipses
,
194 const struct value_print_options
*options
)
196 c_string_type str_type
;
197 const char *type_encoding
;
198 const char *encoding
;
200 str_type
= (classify_type (type
, get_type_arch (type
), &type_encoding
)
207 fputs_filtered ("L", stream
);
210 fputs_filtered ("u", stream
);
213 fputs_filtered ("U", stream
);
217 encoding
= (user_encoding
&& *user_encoding
) ? user_encoding
: type_encoding
;
219 generic_printstr (stream
, type
, string
, length
, encoding
, force_ellipses
,
223 /* Obtain a C string from the inferior storing it in a newly allocated
224 buffer in BUFFER, which should be freed by the caller. If the in-
225 and out-parameter *LENGTH is specified at -1, the string is read
226 until a null character of the appropriate width is found, otherwise
227 the string is read to the length of characters specified. The size
228 of a character is determined by the length of the target type of
229 the pointer or array.
231 If VALUE is an array with a known length, and *LENGTH is -1,
232 the function will not read past the end of the array. However, any
233 declared size of the array is ignored if *LENGTH > 0.
235 On completion, *LENGTH will be set to the size of the string read in
236 characters. (If a length of -1 is specified, the length returned
237 will not include the null character). CHARSET is always set to the
241 c_get_string (struct value
*value
, gdb::unique_xmalloc_ptr
<gdb_byte
> *buffer
,
242 int *length
, struct type
**char_type
,
243 const char **charset
)
246 unsigned int fetchlimit
;
247 struct type
*type
= check_typedef (value_type (value
));
248 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
249 int req_length
= *length
;
250 enum bfd_endian byte_order
251 = gdbarch_byte_order (get_type_arch (type
));
253 if (element_type
== NULL
)
256 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
258 /* If we know the size of the array, we can use it as a limit on
259 the number of characters to be fetched. */
260 if (TYPE_NFIELDS (type
) == 1
261 && TYPE_CODE (TYPE_FIELD_TYPE (type
, 0)) == TYPE_CODE_RANGE
)
263 LONGEST low_bound
, high_bound
;
265 get_discrete_bounds (TYPE_FIELD_TYPE (type
, 0),
266 &low_bound
, &high_bound
);
267 fetchlimit
= high_bound
- low_bound
+ 1;
270 fetchlimit
= UINT_MAX
;
272 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
273 fetchlimit
= UINT_MAX
;
275 /* We work only with arrays and pointers. */
278 if (! c_textual_element_type (element_type
, 0))
280 classify_type (element_type
, get_type_arch (element_type
), charset
);
281 width
= TYPE_LENGTH (element_type
);
283 /* If the string lives in GDB's memory instead of the inferior's,
284 then we just need to copy it to BUFFER. Also, since such strings
285 are arrays with known size, FETCHLIMIT will hold the size of the
287 if ((VALUE_LVAL (value
) == not_lval
288 || VALUE_LVAL (value
) == lval_internalvar
)
289 && fetchlimit
!= UINT_MAX
)
292 const gdb_byte
*contents
= value_contents (value
);
294 /* If a length is specified, use that. */
298 /* Otherwise, look for a null character. */
299 for (i
= 0; i
< fetchlimit
; i
++)
300 if (extract_unsigned_integer (contents
+ i
* width
,
301 width
, byte_order
) == 0)
304 /* I is now either a user-defined length, the number of non-null
305 characters, or FETCHLIMIT. */
307 buffer
->reset ((gdb_byte
*) xmalloc (*length
));
308 memcpy (buffer
->get (), contents
, *length
);
313 CORE_ADDR addr
= value_as_address (value
);
315 /* Prior to the fix for PR 16196 read_string would ignore fetchlimit
316 if length > 0. The old "broken" behaviour is the behaviour we want:
317 The caller may want to fetch 100 bytes from a variable length array
318 implemented using the common idiom of having an array of length 1 at
319 the end of a struct. In this case we want to ignore the declared
320 size of the array. However, it's counterintuitive to implement that
321 behaviour in read_string: what does fetchlimit otherwise mean if
322 length > 0. Therefore we implement the behaviour we want here:
323 If *length > 0, don't specify a fetchlimit. This preserves the
324 previous behaviour. We could move this check above where we know
325 whether the array is declared with a fixed size, but we only want
326 to apply this behaviour when calling read_string. PR 16286. */
328 fetchlimit
= UINT_MAX
;
330 err
= read_string (addr
, *length
, width
, fetchlimit
,
331 byte_order
, buffer
, length
);
333 memory_error (TARGET_XFER_E_IO
, addr
);
336 /* If the LENGTH is specified at -1, we want to return the string
337 length up to the terminating null character. If an actual length
338 was specified, we want to return the length of exactly what was
340 if (req_length
== -1)
341 /* If the last character is null, subtract it from LENGTH. */
343 && extract_unsigned_integer (buffer
->get () + *length
- width
,
344 width
, byte_order
) == 0)
347 /* The read_string function will return the number of bytes read.
348 If length returned from read_string was > 0, return the number of
349 characters read by dividing the number of bytes by width. */
351 *length
= *length
/ width
;
353 *char_type
= element_type
;
359 std::string type_str
= type_to_string (type
);
360 if (!type_str
.empty ())
362 error (_("Trying to read string with inappropriate type `%s'."),
366 error (_("Trying to read string with inappropriate type."));
371 /* Evaluating C and C++ expressions. */
373 /* Convert a UCN. The digits of the UCN start at P and extend no
374 farther than LIMIT. DEST_CHARSET is the name of the character set
375 into which the UCN should be converted. The results are written to
376 OUTPUT. LENGTH is the maximum length of the UCN, either 4 or 8.
377 Returns a pointer to just after the final digit of the UCN. */
380 convert_ucn (char *p
, char *limit
, const char *dest_charset
,
381 struct obstack
*output
, int length
)
383 unsigned long result
= 0;
387 for (i
= 0; i
< length
&& p
< limit
&& ISXDIGIT (*p
); ++i
, ++p
)
388 result
= (result
<< 4) + host_hex_value (*p
);
390 for (i
= 3; i
>= 0; --i
)
392 data
[i
] = result
& 0xff;
396 convert_between_encodings ("UTF-32BE", dest_charset
, data
,
397 4, 4, output
, translit_none
);
402 /* Emit a character, VALUE, which was specified numerically, to
403 OUTPUT. TYPE is the target character type. */
406 emit_numeric_character (struct type
*type
, unsigned long value
,
407 struct obstack
*output
)
411 buffer
= (gdb_byte
*) alloca (TYPE_LENGTH (type
));
412 pack_long (buffer
, type
, value
);
413 obstack_grow (output
, buffer
, TYPE_LENGTH (type
));
416 /* Convert an octal escape sequence. TYPE is the target character
417 type. The digits of the escape sequence begin at P and extend no
418 farther than LIMIT. The result is written to OUTPUT. Returns a
419 pointer to just after the final digit of the escape sequence. */
422 convert_octal (struct type
*type
, char *p
,
423 char *limit
, struct obstack
*output
)
426 unsigned long value
= 0;
429 i
< 3 && p
< limit
&& ISDIGIT (*p
) && *p
!= '8' && *p
!= '9';
432 value
= 8 * value
+ host_hex_value (*p
);
436 emit_numeric_character (type
, value
, output
);
441 /* Convert a hex escape sequence. TYPE is the target character type.
442 The digits of the escape sequence begin at P and extend no farther
443 than LIMIT. The result is written to OUTPUT. Returns a pointer to
444 just after the final digit of the escape sequence. */
447 convert_hex (struct type
*type
, char *p
,
448 char *limit
, struct obstack
*output
)
450 unsigned long value
= 0;
452 while (p
< limit
&& ISXDIGIT (*p
))
454 value
= 16 * value
+ host_hex_value (*p
);
458 emit_numeric_character (type
, value
, output
);
467 error (_("Malformed escape sequence")); \
470 /* Convert an escape sequence to a target format. TYPE is the target
471 character type to use, and DEST_CHARSET is the name of the target
472 character set. The backslash of the escape sequence is at *P, and
473 the escape sequence will not extend past LIMIT. The results are
474 written to OUTPUT. Returns a pointer to just past the final
475 character of the escape sequence. */
478 convert_escape (struct type
*type
, const char *dest_charset
,
479 char *p
, char *limit
, struct obstack
*output
)
481 /* Skip the backslash. */
487 obstack_1grow (output
, '\\');
494 error (_("\\x used with no following hex digits."));
495 p
= convert_hex (type
, p
, limit
, output
);
506 p
= convert_octal (type
, p
, limit
, output
);
512 int length
= *p
== 'u' ? 4 : 8;
516 error (_("\\u used with no following hex digits"));
517 p
= convert_ucn (p
, limit
, dest_charset
, output
, length
);
524 /* Given a single string from a (C-specific) OP_STRING list, convert
525 it to a target string, handling escape sequences specially. The
526 output is written to OUTPUT. DATA is the input string, which has
527 length LEN. DEST_CHARSET is the name of the target character set,
528 and TYPE is the type of target character to use. */
531 parse_one_string (struct obstack
*output
, char *data
, int len
,
532 const char *dest_charset
, struct type
*type
)
542 /* Look for next escape, or the end of the input. */
543 while (p
< limit
&& *p
!= '\\')
545 /* If we saw a run of characters, convert them all. */
547 convert_between_encodings (host_charset (), dest_charset
,
548 (gdb_byte
*) data
, p
- data
, 1,
549 output
, translit_none
);
550 /* If we saw an escape, convert it. */
552 p
= convert_escape (type
, dest_charset
, p
, limit
, output
);
557 /* Expression evaluator for the C language family. Most operations
558 are delegated to evaluate_subexp_standard; see that function for a
559 description of the arguments. */
562 evaluate_subexp_c (struct type
*expect_type
, struct expression
*exp
,
563 int *pos
, enum noside noside
)
565 enum exp_opcode op
= exp
->elts
[*pos
].opcode
;
573 struct value
*result
;
574 c_string_type dest_type
;
575 const char *dest_charset
;
576 int satisfy_expected
= 0;
581 oplen
= longest_to_int (exp
->elts
[*pos
].longconst
);
584 limit
= *pos
+ BYTES_TO_EXP_ELEM (oplen
+ 1);
585 dest_type
= ((enum c_string_type_values
)
586 longest_to_int (exp
->elts
[*pos
].longconst
));
587 switch (dest_type
& ~C_CHAR
)
590 type
= language_string_char_type (exp
->language_defn
,
594 type
= lookup_typename (exp
->language_defn
, exp
->gdbarch
,
598 type
= lookup_typename (exp
->language_defn
, exp
->gdbarch
,
599 "char16_t", NULL
, 0);
602 type
= lookup_typename (exp
->language_defn
, exp
->gdbarch
,
603 "char32_t", NULL
, 0);
606 internal_error (__FILE__
, __LINE__
, _("unhandled c_string_type"));
609 /* Ensure TYPE_LENGTH is valid for TYPE. */
610 check_typedef (type
);
612 /* If the caller expects an array of some integral type,
613 satisfy them. If something odder is expected, rely on the
615 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_ARRAY
)
617 struct type
*element_type
618 = check_typedef (TYPE_TARGET_TYPE (expect_type
));
620 if (TYPE_CODE (element_type
) == TYPE_CODE_INT
621 || TYPE_CODE (element_type
) == TYPE_CODE_CHAR
)
624 satisfy_expected
= 1;
628 dest_charset
= charset_for_string_type (dest_type
, exp
->gdbarch
);
635 len
= longest_to_int (exp
->elts
[*pos
].longconst
);
638 if (noside
!= EVAL_SKIP
)
639 parse_one_string (&output
, &exp
->elts
[*pos
].string
, len
,
641 *pos
+= BYTES_TO_EXP_ELEM (len
);
644 /* Skip the trailing length and opcode. */
647 if (noside
== EVAL_SKIP
)
649 /* Return a dummy value of the appropriate type. */
650 if (expect_type
!= NULL
)
651 result
= allocate_value (expect_type
);
652 else if ((dest_type
& C_CHAR
) != 0)
653 result
= allocate_value (type
);
655 result
= value_cstring ("", 0, type
);
659 if ((dest_type
& C_CHAR
) != 0)
663 if (obstack_object_size (&output
) != TYPE_LENGTH (type
))
664 error (_("Could not convert character "
665 "constant to target character set"));
666 value
= unpack_long (type
, (gdb_byte
*) obstack_base (&output
));
667 result
= value_from_longest (type
, value
);
673 /* Write the terminating character. */
674 for (i
= 0; i
< TYPE_LENGTH (type
); ++i
)
675 obstack_1grow (&output
, 0);
677 if (satisfy_expected
)
679 LONGEST low_bound
, high_bound
;
680 int element_size
= TYPE_LENGTH (type
);
682 if (get_discrete_bounds (TYPE_INDEX_TYPE (expect_type
),
683 &low_bound
, &high_bound
) < 0)
686 high_bound
= (TYPE_LENGTH (expect_type
) / element_size
) - 1;
688 if (obstack_object_size (&output
) / element_size
689 > (high_bound
- low_bound
+ 1))
690 error (_("Too many array elements"));
692 result
= allocate_value (expect_type
);
693 memcpy (value_contents_raw (result
), obstack_base (&output
),
694 obstack_object_size (&output
));
697 result
= value_cstring ((const char *) obstack_base (&output
),
698 obstack_object_size (&output
),
708 return evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
711 /* la_watch_location_expression for C. */
713 gdb::unique_xmalloc_ptr
<char>
714 c_watch_location_expression (struct type
*type
, CORE_ADDR addr
)
716 type
= check_typedef (TYPE_TARGET_TYPE (check_typedef (type
)));
717 std::string name
= type_to_string (type
);
718 return gdb::unique_xmalloc_ptr
<char>
719 (xstrprintf ("* (%s *) %s", name
.c_str (), core_addr_to_string (addr
)));
723 /* Table mapping opcodes into strings for printing operators
724 and precedences of the operators. */
726 const struct op_print c_op_print_tab
[] =
728 {",", BINOP_COMMA
, PREC_COMMA
, 0},
729 {"=", BINOP_ASSIGN
, PREC_ASSIGN
, 1},
730 {"||", BINOP_LOGICAL_OR
, PREC_LOGICAL_OR
, 0},
731 {"&&", BINOP_LOGICAL_AND
, PREC_LOGICAL_AND
, 0},
732 {"|", BINOP_BITWISE_IOR
, PREC_BITWISE_IOR
, 0},
733 {"^", BINOP_BITWISE_XOR
, PREC_BITWISE_XOR
, 0},
734 {"&", BINOP_BITWISE_AND
, PREC_BITWISE_AND
, 0},
735 {"==", BINOP_EQUAL
, PREC_EQUAL
, 0},
736 {"!=", BINOP_NOTEQUAL
, PREC_EQUAL
, 0},
737 {"<=", BINOP_LEQ
, PREC_ORDER
, 0},
738 {">=", BINOP_GEQ
, PREC_ORDER
, 0},
739 {">", BINOP_GTR
, PREC_ORDER
, 0},
740 {"<", BINOP_LESS
, PREC_ORDER
, 0},
741 {">>", BINOP_RSH
, PREC_SHIFT
, 0},
742 {"<<", BINOP_LSH
, PREC_SHIFT
, 0},
743 {"+", BINOP_ADD
, PREC_ADD
, 0},
744 {"-", BINOP_SUB
, PREC_ADD
, 0},
745 {"*", BINOP_MUL
, PREC_MUL
, 0},
746 {"/", BINOP_DIV
, PREC_MUL
, 0},
747 {"%", BINOP_REM
, PREC_MUL
, 0},
748 {"@", BINOP_REPEAT
, PREC_REPEAT
, 0},
749 {"+", UNOP_PLUS
, PREC_PREFIX
, 0},
750 {"-", UNOP_NEG
, PREC_PREFIX
, 0},
751 {"!", UNOP_LOGICAL_NOT
, PREC_PREFIX
, 0},
752 {"~", UNOP_COMPLEMENT
, PREC_PREFIX
, 0},
753 {"*", UNOP_IND
, PREC_PREFIX
, 0},
754 {"&", UNOP_ADDR
, PREC_PREFIX
, 0},
755 {"sizeof ", UNOP_SIZEOF
, PREC_PREFIX
, 0},
756 {"alignof ", UNOP_ALIGNOF
, PREC_PREFIX
, 0},
757 {"++", UNOP_PREINCREMENT
, PREC_PREFIX
, 0},
758 {"--", UNOP_PREDECREMENT
, PREC_PREFIX
, 0},
759 {NULL
, OP_NULL
, PREC_PREFIX
, 0}
762 enum c_primitive_types
{
763 c_primitive_type_int
,
764 c_primitive_type_long
,
765 c_primitive_type_short
,
766 c_primitive_type_char
,
767 c_primitive_type_float
,
768 c_primitive_type_double
,
769 c_primitive_type_void
,
770 c_primitive_type_long_long
,
771 c_primitive_type_signed_char
,
772 c_primitive_type_unsigned_char
,
773 c_primitive_type_unsigned_short
,
774 c_primitive_type_unsigned_int
,
775 c_primitive_type_unsigned_long
,
776 c_primitive_type_unsigned_long_long
,
777 c_primitive_type_long_double
,
778 c_primitive_type_complex
,
779 c_primitive_type_double_complex
,
780 c_primitive_type_decfloat
,
781 c_primitive_type_decdouble
,
782 c_primitive_type_declong
,
787 c_language_arch_info (struct gdbarch
*gdbarch
,
788 struct language_arch_info
*lai
)
790 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
792 lai
->string_char_type
= builtin
->builtin_char
;
793 lai
->primitive_type_vector
794 = GDBARCH_OBSTACK_CALLOC (gdbarch
, nr_c_primitive_types
+ 1,
796 lai
->primitive_type_vector
[c_primitive_type_int
] = builtin
->builtin_int
;
797 lai
->primitive_type_vector
[c_primitive_type_long
] = builtin
->builtin_long
;
798 lai
->primitive_type_vector
[c_primitive_type_short
] = builtin
->builtin_short
;
799 lai
->primitive_type_vector
[c_primitive_type_char
] = builtin
->builtin_char
;
800 lai
->primitive_type_vector
[c_primitive_type_float
] = builtin
->builtin_float
;
801 lai
->primitive_type_vector
[c_primitive_type_double
] = builtin
->builtin_double
;
802 lai
->primitive_type_vector
[c_primitive_type_void
] = builtin
->builtin_void
;
803 lai
->primitive_type_vector
[c_primitive_type_long_long
] = builtin
->builtin_long_long
;
804 lai
->primitive_type_vector
[c_primitive_type_signed_char
] = builtin
->builtin_signed_char
;
805 lai
->primitive_type_vector
[c_primitive_type_unsigned_char
] = builtin
->builtin_unsigned_char
;
806 lai
->primitive_type_vector
[c_primitive_type_unsigned_short
] = builtin
->builtin_unsigned_short
;
807 lai
->primitive_type_vector
[c_primitive_type_unsigned_int
] = builtin
->builtin_unsigned_int
;
808 lai
->primitive_type_vector
[c_primitive_type_unsigned_long
] = builtin
->builtin_unsigned_long
;
809 lai
->primitive_type_vector
[c_primitive_type_unsigned_long_long
] = builtin
->builtin_unsigned_long_long
;
810 lai
->primitive_type_vector
[c_primitive_type_long_double
] = builtin
->builtin_long_double
;
811 lai
->primitive_type_vector
[c_primitive_type_complex
] = builtin
->builtin_complex
;
812 lai
->primitive_type_vector
[c_primitive_type_double_complex
] = builtin
->builtin_double_complex
;
813 lai
->primitive_type_vector
[c_primitive_type_decfloat
] = builtin
->builtin_decfloat
;
814 lai
->primitive_type_vector
[c_primitive_type_decdouble
] = builtin
->builtin_decdouble
;
815 lai
->primitive_type_vector
[c_primitive_type_declong
] = builtin
->builtin_declong
;
817 lai
->bool_type_default
= builtin
->builtin_int
;
820 const struct exp_descriptor exp_descriptor_c
=
822 print_subexp_standard
,
823 operator_length_standard
,
824 operator_check_standard
,
826 dump_subexp_body_standard
,
830 static const char *c_extensions
[] =
835 extern const struct language_defn c_language_defn
=
837 "c", /* Language name */
848 c_printchar
, /* Print a character constant */
849 c_printstr
, /* Function to print string constant */
850 c_emit_char
, /* Print a single char */
851 c_print_type
, /* Print a type using appropriate syntax */
852 c_print_typedef
, /* Print a typedef using appropriate syntax */
853 c_val_print
, /* Print a value using appropriate syntax */
854 c_value_print
, /* Print a top-level value */
855 default_read_var_value
, /* la_read_var_value */
856 NULL
, /* Language specific skip_trampoline */
857 NULL
, /* name_of_this */
858 true, /* la_store_sym_names_in_linkage_form_p */
859 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
860 basic_lookup_transparent_type
,/* lookup_transparent_type */
861 NULL
, /* Language specific symbol demangler */
863 NULL
, /* Language specific
864 class_name_from_physname */
865 c_op_print_tab
, /* expression operators for printing */
866 1, /* c-style arrays */
867 0, /* String lower bound */
868 default_word_break_characters
,
869 default_collect_symbol_completion_matches
,
870 c_language_arch_info
,
871 default_print_array_index
,
872 default_pass_by_reference
,
874 c_watch_location_expression
,
875 NULL
, /* la_get_symbol_name_matcher */
876 iterate_over_symbols
,
877 default_search_name_hash
,
879 c_get_compile_context
,
884 enum cplus_primitive_types
{
885 cplus_primitive_type_int
,
886 cplus_primitive_type_long
,
887 cplus_primitive_type_short
,
888 cplus_primitive_type_char
,
889 cplus_primitive_type_float
,
890 cplus_primitive_type_double
,
891 cplus_primitive_type_void
,
892 cplus_primitive_type_long_long
,
893 cplus_primitive_type_signed_char
,
894 cplus_primitive_type_unsigned_char
,
895 cplus_primitive_type_unsigned_short
,
896 cplus_primitive_type_unsigned_int
,
897 cplus_primitive_type_unsigned_long
,
898 cplus_primitive_type_unsigned_long_long
,
899 cplus_primitive_type_long_double
,
900 cplus_primitive_type_complex
,
901 cplus_primitive_type_double_complex
,
902 cplus_primitive_type_bool
,
903 cplus_primitive_type_decfloat
,
904 cplus_primitive_type_decdouble
,
905 cplus_primitive_type_declong
,
906 cplus_primitive_type_char16_t
,
907 cplus_primitive_type_char32_t
,
908 cplus_primitive_type_wchar_t
,
909 nr_cplus_primitive_types
913 cplus_language_arch_info (struct gdbarch
*gdbarch
,
914 struct language_arch_info
*lai
)
916 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
918 lai
->string_char_type
= builtin
->builtin_char
;
919 lai
->primitive_type_vector
920 = GDBARCH_OBSTACK_CALLOC (gdbarch
, nr_cplus_primitive_types
+ 1,
922 lai
->primitive_type_vector
[cplus_primitive_type_int
]
923 = builtin
->builtin_int
;
924 lai
->primitive_type_vector
[cplus_primitive_type_long
]
925 = builtin
->builtin_long
;
926 lai
->primitive_type_vector
[cplus_primitive_type_short
]
927 = builtin
->builtin_short
;
928 lai
->primitive_type_vector
[cplus_primitive_type_char
]
929 = builtin
->builtin_char
;
930 lai
->primitive_type_vector
[cplus_primitive_type_float
]
931 = builtin
->builtin_float
;
932 lai
->primitive_type_vector
[cplus_primitive_type_double
]
933 = builtin
->builtin_double
;
934 lai
->primitive_type_vector
[cplus_primitive_type_void
]
935 = builtin
->builtin_void
;
936 lai
->primitive_type_vector
[cplus_primitive_type_long_long
]
937 = builtin
->builtin_long_long
;
938 lai
->primitive_type_vector
[cplus_primitive_type_signed_char
]
939 = builtin
->builtin_signed_char
;
940 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_char
]
941 = builtin
->builtin_unsigned_char
;
942 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_short
]
943 = builtin
->builtin_unsigned_short
;
944 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_int
]
945 = builtin
->builtin_unsigned_int
;
946 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_long
]
947 = builtin
->builtin_unsigned_long
;
948 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_long_long
]
949 = builtin
->builtin_unsigned_long_long
;
950 lai
->primitive_type_vector
[cplus_primitive_type_long_double
]
951 = builtin
->builtin_long_double
;
952 lai
->primitive_type_vector
[cplus_primitive_type_complex
]
953 = builtin
->builtin_complex
;
954 lai
->primitive_type_vector
[cplus_primitive_type_double_complex
]
955 = builtin
->builtin_double_complex
;
956 lai
->primitive_type_vector
[cplus_primitive_type_bool
]
957 = builtin
->builtin_bool
;
958 lai
->primitive_type_vector
[cplus_primitive_type_decfloat
]
959 = builtin
->builtin_decfloat
;
960 lai
->primitive_type_vector
[cplus_primitive_type_decdouble
]
961 = builtin
->builtin_decdouble
;
962 lai
->primitive_type_vector
[cplus_primitive_type_declong
]
963 = builtin
->builtin_declong
;
964 lai
->primitive_type_vector
[cplus_primitive_type_char16_t
]
965 = builtin
->builtin_char16
;
966 lai
->primitive_type_vector
[cplus_primitive_type_char32_t
]
967 = builtin
->builtin_char32
;
968 lai
->primitive_type_vector
[cplus_primitive_type_wchar_t
]
969 = builtin
->builtin_wchar
;
971 lai
->bool_type_symbol
= "bool";
972 lai
->bool_type_default
= builtin
->builtin_bool
;
975 static const char *cplus_extensions
[] =
977 ".C", ".cc", ".cp", ".cpp", ".cxx", ".c++", NULL
980 extern const struct language_defn cplus_language_defn
=
982 "c++", /* Language name */
993 c_printchar
, /* Print a character constant */
994 c_printstr
, /* Function to print string constant */
995 c_emit_char
, /* Print a single char */
996 c_print_type
, /* Print a type using appropriate syntax */
997 c_print_typedef
, /* Print a typedef using appropriate syntax */
998 c_val_print
, /* Print a value using appropriate syntax */
999 c_value_print
, /* Print a top-level value */
1000 default_read_var_value
, /* la_read_var_value */
1001 cplus_skip_trampoline
, /* Language specific skip_trampoline */
1002 "this", /* name_of_this */
1003 false, /* la_store_sym_names_in_linkage_form_p */
1004 cp_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
1005 cp_lookup_transparent_type
, /* lookup_transparent_type */
1006 gdb_demangle
, /* Language specific symbol demangler */
1007 gdb_sniff_from_mangled_name
,
1008 cp_class_name_from_physname
, /* Language specific
1009 class_name_from_physname */
1010 c_op_print_tab
, /* expression operators for printing */
1011 1, /* c-style arrays */
1012 0, /* String lower bound */
1013 default_word_break_characters
,
1014 default_collect_symbol_completion_matches
,
1015 cplus_language_arch_info
,
1016 default_print_array_index
,
1017 cp_pass_by_reference
,
1019 c_watch_location_expression
,
1020 cp_get_symbol_name_matcher
,
1021 iterate_over_symbols
,
1022 cp_search_name_hash
,
1024 cplus_get_compile_context
,
1025 cplus_compute_program
,
1029 static const char *asm_extensions
[] =
1031 ".s", ".sx", ".S", NULL
1034 extern const struct language_defn asm_language_defn
=
1036 "asm", /* Language name */
1047 c_printchar
, /* Print a character constant */
1048 c_printstr
, /* Function to print string constant */
1049 c_emit_char
, /* Print a single char */
1050 c_print_type
, /* Print a type using appropriate syntax */
1051 c_print_typedef
, /* Print a typedef using appropriate syntax */
1052 c_val_print
, /* Print a value using appropriate syntax */
1053 c_value_print
, /* Print a top-level value */
1054 default_read_var_value
, /* la_read_var_value */
1055 NULL
, /* Language specific skip_trampoline */
1056 NULL
, /* name_of_this */
1057 true, /* la_store_sym_names_in_linkage_form_p */
1058 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
1059 basic_lookup_transparent_type
,/* lookup_transparent_type */
1060 NULL
, /* Language specific symbol demangler */
1062 NULL
, /* Language specific
1063 class_name_from_physname */
1064 c_op_print_tab
, /* expression operators for printing */
1065 1, /* c-style arrays */
1066 0, /* String lower bound */
1067 default_word_break_characters
,
1068 default_collect_symbol_completion_matches
,
1069 c_language_arch_info
, /* FIXME: la_language_arch_info. */
1070 default_print_array_index
,
1071 default_pass_by_reference
,
1073 c_watch_location_expression
,
1074 NULL
, /* la_get_symbol_name_matcher */
1075 iterate_over_symbols
,
1076 default_search_name_hash
,
1077 &default_varobj_ops
,
1083 /* The following language_defn does not represent a real language.
1084 It just provides a minimal support a-la-C that should allow users
1085 to do some simple operations when debugging applications that use
1086 a language currently not supported by GDB. */
1088 extern const struct language_defn minimal_language_defn
=
1090 "minimal", /* Language name */
1101 c_printchar
, /* Print a character constant */
1102 c_printstr
, /* Function to print string constant */
1103 c_emit_char
, /* Print a single char */
1104 c_print_type
, /* Print a type using appropriate syntax */
1105 c_print_typedef
, /* Print a typedef using appropriate syntax */
1106 c_val_print
, /* Print a value using appropriate syntax */
1107 c_value_print
, /* Print a top-level value */
1108 default_read_var_value
, /* la_read_var_value */
1109 NULL
, /* Language specific skip_trampoline */
1110 NULL
, /* name_of_this */
1111 true, /* la_store_sym_names_in_linkage_form_p */
1112 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
1113 basic_lookup_transparent_type
,/* lookup_transparent_type */
1114 NULL
, /* Language specific symbol demangler */
1116 NULL
, /* Language specific
1117 class_name_from_physname */
1118 c_op_print_tab
, /* expression operators for printing */
1119 1, /* c-style arrays */
1120 0, /* String lower bound */
1121 default_word_break_characters
,
1122 default_collect_symbol_completion_matches
,
1123 c_language_arch_info
,
1124 default_print_array_index
,
1125 default_pass_by_reference
,
1127 c_watch_location_expression
,
1128 NULL
, /* la_get_symbol_name_matcher */
1129 iterate_over_symbols
,
1130 default_search_name_hash
,
1131 &default_varobj_ops
,