1 /* C language support routines for GDB, the GNU debugger.
3 Copyright (C) 1992-2018 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "expression.h"
24 #include "parser-defs.h"
28 #include "c-support.h"
30 #include "macroscope.h"
34 #include "cp-support.h"
35 #include "gdb_obstack.h"
39 /* Given a C string type, STR_TYPE, return the corresponding target
40 character set name. */
43 charset_for_string_type (c_string_type str_type
, struct gdbarch
*gdbarch
)
45 switch (str_type
& ~C_CHAR
)
48 return target_charset (gdbarch
);
50 return target_wide_charset (gdbarch
);
52 /* FIXME: UTF-16 is not always correct. */
53 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
)
58 /* FIXME: UTF-32 is not always correct. */
59 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
)
64 internal_error (__FILE__
, __LINE__
, _("unhandled c_string_type"));
67 /* Classify ELTTYPE according to what kind of character it is. Return
68 the enum constant representing the character type. Also set
69 *ENCODING to the name of the character set to use when converting
70 characters of this type in target BYTE_ORDER to the host character
74 classify_type (struct type
*elttype
, struct gdbarch
*gdbarch
,
75 const char **encoding
)
79 /* We loop because ELTTYPE may be a typedef, and we want to
80 successively peel each typedef until we reach a type we
81 understand. We don't use CHECK_TYPEDEF because that will strip
82 all typedefs at once -- but in C, wchar_t is itself a typedef, so
83 that would do the wrong thing. */
86 const char *name
= TYPE_NAME (elttype
);
88 if (TYPE_CODE (elttype
) == TYPE_CODE_CHAR
|| !name
)
94 if (!strcmp (name
, "wchar_t"))
100 if (!strcmp (name
, "char16_t"))
106 if (!strcmp (name
, "char32_t"))
112 if (TYPE_CODE (elttype
) != TYPE_CODE_TYPEDEF
)
115 /* Call for side effects. */
116 check_typedef (elttype
);
118 if (TYPE_TARGET_TYPE (elttype
))
119 elttype
= TYPE_TARGET_TYPE (elttype
);
122 /* Perhaps check_typedef did not update the target type. In
123 this case, force the lookup again and hope it works out.
124 It never will for C, but it might for C++. */
125 elttype
= check_typedef (elttype
);
134 *encoding
= charset_for_string_type (result
, gdbarch
);
139 /* Print the character C on STREAM as part of the contents of a
140 literal string whose delimiter is QUOTER. Note that that format
141 for printing characters and strings is language specific. */
144 c_emit_char (int c
, struct type
*type
,
145 struct ui_file
*stream
, int quoter
)
147 const char *encoding
;
149 classify_type (type
, get_type_arch (type
), &encoding
);
150 generic_emit_char (c
, type
, stream
, quoter
, encoding
);
154 c_printchar (int c
, struct type
*type
, struct ui_file
*stream
)
156 c_string_type str_type
;
158 str_type
= classify_type (type
, get_type_arch (type
), NULL
);
164 fputc_filtered ('L', stream
);
167 fputc_filtered ('u', stream
);
170 fputc_filtered ('U', stream
);
174 fputc_filtered ('\'', stream
);
175 LA_EMIT_CHAR (c
, type
, stream
, '\'');
176 fputc_filtered ('\'', stream
);
179 /* Print the character string STRING, printing at most LENGTH
180 characters. LENGTH is -1 if the string is nul terminated. Each
181 character is WIDTH bytes long. Printing stops early if the number
182 hits print_max; repeat counts are printed as appropriate. Print
183 ellipses at the end if we had to stop before printing LENGTH
184 characters, or if FORCE_ELLIPSES. */
187 c_printstr (struct ui_file
*stream
, struct type
*type
,
188 const gdb_byte
*string
, unsigned int length
,
189 const char *user_encoding
, int force_ellipses
,
190 const struct value_print_options
*options
)
192 c_string_type str_type
;
193 const char *type_encoding
;
194 const char *encoding
;
196 str_type
= (classify_type (type
, get_type_arch (type
), &type_encoding
)
203 fputs_filtered ("L", stream
);
206 fputs_filtered ("u", stream
);
209 fputs_filtered ("U", stream
);
213 encoding
= (user_encoding
&& *user_encoding
) ? user_encoding
: type_encoding
;
215 generic_printstr (stream
, type
, string
, length
, encoding
, force_ellipses
,
219 /* Obtain a C string from the inferior storing it in a newly allocated
220 buffer in BUFFER, which should be freed by the caller. If the in-
221 and out-parameter *LENGTH is specified at -1, the string is read
222 until a null character of the appropriate width is found, otherwise
223 the string is read to the length of characters specified. The size
224 of a character is determined by the length of the target type of
225 the pointer or array.
227 If VALUE is an array with a known length, and *LENGTH is -1,
228 the function will not read past the end of the array. However, any
229 declared size of the array is ignored if *LENGTH > 0.
231 On completion, *LENGTH will be set to the size of the string read in
232 characters. (If a length of -1 is specified, the length returned
233 will not include the null character). CHARSET is always set to the
237 c_get_string (struct value
*value
, gdb_byte
**buffer
,
238 int *length
, struct type
**char_type
,
239 const char **charset
)
242 unsigned int fetchlimit
;
243 struct type
*type
= check_typedef (value_type (value
));
244 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
245 int req_length
= *length
;
246 enum bfd_endian byte_order
247 = gdbarch_byte_order (get_type_arch (type
));
249 if (element_type
== NULL
)
252 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
254 /* If we know the size of the array, we can use it as a limit on
255 the number of characters to be fetched. */
256 if (TYPE_NFIELDS (type
) == 1
257 && TYPE_CODE (TYPE_FIELD_TYPE (type
, 0)) == TYPE_CODE_RANGE
)
259 LONGEST low_bound
, high_bound
;
261 get_discrete_bounds (TYPE_FIELD_TYPE (type
, 0),
262 &low_bound
, &high_bound
);
263 fetchlimit
= high_bound
- low_bound
+ 1;
266 fetchlimit
= UINT_MAX
;
268 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
269 fetchlimit
= UINT_MAX
;
271 /* We work only with arrays and pointers. */
274 if (! c_textual_element_type (element_type
, 0))
276 classify_type (element_type
, get_type_arch (element_type
), charset
);
277 width
= TYPE_LENGTH (element_type
);
279 /* If the string lives in GDB's memory instead of the inferior's,
280 then we just need to copy it to BUFFER. Also, since such strings
281 are arrays with known size, FETCHLIMIT will hold the size of the
283 if ((VALUE_LVAL (value
) == not_lval
284 || VALUE_LVAL (value
) == lval_internalvar
)
285 && fetchlimit
!= UINT_MAX
)
288 const gdb_byte
*contents
= value_contents (value
);
290 /* If a length is specified, use that. */
294 /* Otherwise, look for a null character. */
295 for (i
= 0; i
< fetchlimit
; i
++)
296 if (extract_unsigned_integer (contents
+ i
* width
,
297 width
, byte_order
) == 0)
300 /* I is now either a user-defined length, the number of non-null
301 characters, or FETCHLIMIT. */
303 *buffer
= (gdb_byte
*) xmalloc (*length
);
304 memcpy (*buffer
, contents
, *length
);
309 CORE_ADDR addr
= value_as_address (value
);
311 /* Prior to the fix for PR 16196 read_string would ignore fetchlimit
312 if length > 0. The old "broken" behaviour is the behaviour we want:
313 The caller may want to fetch 100 bytes from a variable length array
314 implemented using the common idiom of having an array of length 1 at
315 the end of a struct. In this case we want to ignore the declared
316 size of the array. However, it's counterintuitive to implement that
317 behaviour in read_string: what does fetchlimit otherwise mean if
318 length > 0. Therefore we implement the behaviour we want here:
319 If *length > 0, don't specify a fetchlimit. This preserves the
320 previous behaviour. We could move this check above where we know
321 whether the array is declared with a fixed size, but we only want
322 to apply this behaviour when calling read_string. PR 16286. */
324 fetchlimit
= UINT_MAX
;
326 err
= read_string (addr
, *length
, width
, fetchlimit
,
327 byte_order
, buffer
, length
);
331 memory_error (TARGET_XFER_E_IO
, addr
);
335 /* If the LENGTH is specified at -1, we want to return the string
336 length up to the terminating null character. If an actual length
337 was specified, we want to return the length of exactly what was
339 if (req_length
== -1)
340 /* If the last character is null, subtract it from LENGTH. */
342 && extract_unsigned_integer (*buffer
+ *length
- width
,
343 width
, byte_order
) == 0)
346 /* The read_string function will return the number of bytes read.
347 If length returned from read_string was > 0, return the number of
348 characters read by dividing the number of bytes by width. */
350 *length
= *length
/ width
;
352 *char_type
= element_type
;
358 std::string type_str
= type_to_string (type
);
359 if (!type_str
.empty ())
361 error (_("Trying to read string with inappropriate type `%s'."),
365 error (_("Trying to read string with inappropriate type."));
370 /* Evaluating C and C++ expressions. */
372 /* Convert a UCN. The digits of the UCN start at P and extend no
373 farther than LIMIT. DEST_CHARSET is the name of the character set
374 into which the UCN should be converted. The results are written to
375 OUTPUT. LENGTH is the maximum length of the UCN, either 4 or 8.
376 Returns a pointer to just after the final digit of the UCN. */
379 convert_ucn (char *p
, char *limit
, const char *dest_charset
,
380 struct obstack
*output
, int length
)
382 unsigned long result
= 0;
386 for (i
= 0; i
< length
&& p
< limit
&& ISXDIGIT (*p
); ++i
, ++p
)
387 result
= (result
<< 4) + host_hex_value (*p
);
389 for (i
= 3; i
>= 0; --i
)
391 data
[i
] = result
& 0xff;
395 convert_between_encodings ("UTF-32BE", dest_charset
, data
,
396 4, 4, output
, translit_none
);
401 /* Emit a character, VALUE, which was specified numerically, to
402 OUTPUT. TYPE is the target character type. */
405 emit_numeric_character (struct type
*type
, unsigned long value
,
406 struct obstack
*output
)
410 buffer
= (gdb_byte
*) alloca (TYPE_LENGTH (type
));
411 pack_long (buffer
, type
, value
);
412 obstack_grow (output
, buffer
, TYPE_LENGTH (type
));
415 /* Convert an octal escape sequence. TYPE is the target character
416 type. The digits of the escape sequence begin at P and extend no
417 farther than LIMIT. The result is written to OUTPUT. Returns a
418 pointer to just after the final digit of the escape sequence. */
421 convert_octal (struct type
*type
, char *p
,
422 char *limit
, struct obstack
*output
)
425 unsigned long value
= 0;
428 i
< 3 && p
< limit
&& ISDIGIT (*p
) && *p
!= '8' && *p
!= '9';
431 value
= 8 * value
+ host_hex_value (*p
);
435 emit_numeric_character (type
, value
, output
);
440 /* Convert a hex escape sequence. TYPE is the target character type.
441 The digits of the escape sequence begin at P and extend no farther
442 than LIMIT. The result is written to OUTPUT. Returns a pointer to
443 just after the final digit of the escape sequence. */
446 convert_hex (struct type
*type
, char *p
,
447 char *limit
, struct obstack
*output
)
449 unsigned long value
= 0;
451 while (p
< limit
&& ISXDIGIT (*p
))
453 value
= 16 * value
+ host_hex_value (*p
);
457 emit_numeric_character (type
, value
, output
);
466 error (_("Malformed escape sequence")); \
469 /* Convert an escape sequence to a target format. TYPE is the target
470 character type to use, and DEST_CHARSET is the name of the target
471 character set. The backslash of the escape sequence is at *P, and
472 the escape sequence will not extend past LIMIT. The results are
473 written to OUTPUT. Returns a pointer to just past the final
474 character of the escape sequence. */
477 convert_escape (struct type
*type
, const char *dest_charset
,
478 char *p
, char *limit
, struct obstack
*output
)
480 /* Skip the backslash. */
486 obstack_1grow (output
, '\\');
493 error (_("\\x used with no following hex digits."));
494 p
= convert_hex (type
, p
, limit
, output
);
505 p
= convert_octal (type
, p
, limit
, output
);
511 int length
= *p
== 'u' ? 4 : 8;
515 error (_("\\u used with no following hex digits"));
516 p
= convert_ucn (p
, limit
, dest_charset
, output
, length
);
523 /* Given a single string from a (C-specific) OP_STRING list, convert
524 it to a target string, handling escape sequences specially. The
525 output is written to OUTPUT. DATA is the input string, which has
526 length LEN. DEST_CHARSET is the name of the target character set,
527 and TYPE is the type of target character to use. */
530 parse_one_string (struct obstack
*output
, char *data
, int len
,
531 const char *dest_charset
, struct type
*type
)
541 /* Look for next escape, or the end of the input. */
542 while (p
< limit
&& *p
!= '\\')
544 /* If we saw a run of characters, convert them all. */
546 convert_between_encodings (host_charset (), dest_charset
,
547 (gdb_byte
*) data
, p
- data
, 1,
548 output
, translit_none
);
549 /* If we saw an escape, convert it. */
551 p
= convert_escape (type
, dest_charset
, p
, limit
, output
);
556 /* Expression evaluator for the C language family. Most operations
557 are delegated to evaluate_subexp_standard; see that function for a
558 description of the arguments. */
561 evaluate_subexp_c (struct type
*expect_type
, struct expression
*exp
,
562 int *pos
, enum noside noside
)
564 enum exp_opcode op
= exp
->elts
[*pos
].opcode
;
572 struct value
*result
;
573 c_string_type dest_type
;
574 const char *dest_charset
;
575 int satisfy_expected
= 0;
580 oplen
= longest_to_int (exp
->elts
[*pos
].longconst
);
583 limit
= *pos
+ BYTES_TO_EXP_ELEM (oplen
+ 1);
584 dest_type
= ((enum c_string_type_values
)
585 longest_to_int (exp
->elts
[*pos
].longconst
));
586 switch (dest_type
& ~C_CHAR
)
589 type
= language_string_char_type (exp
->language_defn
,
593 type
= lookup_typename (exp
->language_defn
, exp
->gdbarch
,
597 type
= lookup_typename (exp
->language_defn
, exp
->gdbarch
,
598 "char16_t", NULL
, 0);
601 type
= lookup_typename (exp
->language_defn
, exp
->gdbarch
,
602 "char32_t", NULL
, 0);
605 internal_error (__FILE__
, __LINE__
, _("unhandled c_string_type"));
608 /* Ensure TYPE_LENGTH is valid for TYPE. */
609 check_typedef (type
);
611 /* If the caller expects an array of some integral type,
612 satisfy them. If something odder is expected, rely on the
614 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_ARRAY
)
616 struct type
*element_type
617 = check_typedef (TYPE_TARGET_TYPE (expect_type
));
619 if (TYPE_CODE (element_type
) == TYPE_CODE_INT
620 || TYPE_CODE (element_type
) == TYPE_CODE_CHAR
)
623 satisfy_expected
= 1;
627 dest_charset
= charset_for_string_type (dest_type
, exp
->gdbarch
);
634 len
= longest_to_int (exp
->elts
[*pos
].longconst
);
637 if (noside
!= EVAL_SKIP
)
638 parse_one_string (&output
, &exp
->elts
[*pos
].string
, len
,
640 *pos
+= BYTES_TO_EXP_ELEM (len
);
643 /* Skip the trailing length and opcode. */
646 if (noside
== EVAL_SKIP
)
648 /* Return a dummy value of the appropriate type. */
649 if (expect_type
!= NULL
)
650 result
= allocate_value (expect_type
);
651 else if ((dest_type
& C_CHAR
) != 0)
652 result
= allocate_value (type
);
654 result
= value_cstring ("", 0, type
);
658 if ((dest_type
& C_CHAR
) != 0)
662 if (obstack_object_size (&output
) != TYPE_LENGTH (type
))
663 error (_("Could not convert character "
664 "constant to target character set"));
665 value
= unpack_long (type
, (gdb_byte
*) obstack_base (&output
));
666 result
= value_from_longest (type
, value
);
672 /* Write the terminating character. */
673 for (i
= 0; i
< TYPE_LENGTH (type
); ++i
)
674 obstack_1grow (&output
, 0);
676 if (satisfy_expected
)
678 LONGEST low_bound
, high_bound
;
679 int element_size
= TYPE_LENGTH (type
);
681 if (get_discrete_bounds (TYPE_INDEX_TYPE (expect_type
),
682 &low_bound
, &high_bound
) < 0)
685 high_bound
= (TYPE_LENGTH (expect_type
) / element_size
) - 1;
687 if (obstack_object_size (&output
) / element_size
688 > (high_bound
- low_bound
+ 1))
689 error (_("Too many array elements"));
691 result
= allocate_value (expect_type
);
692 memcpy (value_contents_raw (result
), obstack_base (&output
),
693 obstack_object_size (&output
));
696 result
= value_cstring ((const char *) obstack_base (&output
),
697 obstack_object_size (&output
),
707 return evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
710 /* la_watch_location_expression for C. */
712 gdb::unique_xmalloc_ptr
<char>
713 c_watch_location_expression (struct type
*type
, CORE_ADDR addr
)
715 type
= check_typedef (TYPE_TARGET_TYPE (check_typedef (type
)));
716 std::string name
= type_to_string (type
);
717 return gdb::unique_xmalloc_ptr
<char>
718 (xstrprintf ("* (%s *) %s", name
.c_str (), core_addr_to_string (addr
)));
722 /* Table mapping opcodes into strings for printing operators
723 and precedences of the operators. */
725 const struct op_print c_op_print_tab
[] =
727 {",", BINOP_COMMA
, PREC_COMMA
, 0},
728 {"=", BINOP_ASSIGN
, PREC_ASSIGN
, 1},
729 {"||", BINOP_LOGICAL_OR
, PREC_LOGICAL_OR
, 0},
730 {"&&", BINOP_LOGICAL_AND
, PREC_LOGICAL_AND
, 0},
731 {"|", BINOP_BITWISE_IOR
, PREC_BITWISE_IOR
, 0},
732 {"^", BINOP_BITWISE_XOR
, PREC_BITWISE_XOR
, 0},
733 {"&", BINOP_BITWISE_AND
, PREC_BITWISE_AND
, 0},
734 {"==", BINOP_EQUAL
, PREC_EQUAL
, 0},
735 {"!=", BINOP_NOTEQUAL
, PREC_EQUAL
, 0},
736 {"<=", BINOP_LEQ
, PREC_ORDER
, 0},
737 {">=", BINOP_GEQ
, PREC_ORDER
, 0},
738 {">", BINOP_GTR
, PREC_ORDER
, 0},
739 {"<", BINOP_LESS
, PREC_ORDER
, 0},
740 {">>", BINOP_RSH
, PREC_SHIFT
, 0},
741 {"<<", BINOP_LSH
, PREC_SHIFT
, 0},
742 {"+", BINOP_ADD
, PREC_ADD
, 0},
743 {"-", BINOP_SUB
, PREC_ADD
, 0},
744 {"*", BINOP_MUL
, PREC_MUL
, 0},
745 {"/", BINOP_DIV
, PREC_MUL
, 0},
746 {"%", BINOP_REM
, PREC_MUL
, 0},
747 {"@", BINOP_REPEAT
, PREC_REPEAT
, 0},
748 {"+", UNOP_PLUS
, PREC_PREFIX
, 0},
749 {"-", UNOP_NEG
, PREC_PREFIX
, 0},
750 {"!", UNOP_LOGICAL_NOT
, PREC_PREFIX
, 0},
751 {"~", UNOP_COMPLEMENT
, PREC_PREFIX
, 0},
752 {"*", UNOP_IND
, PREC_PREFIX
, 0},
753 {"&", UNOP_ADDR
, PREC_PREFIX
, 0},
754 {"sizeof ", UNOP_SIZEOF
, PREC_PREFIX
, 0},
755 {"alignof ", UNOP_ALIGNOF
, PREC_PREFIX
, 0},
756 {"++", UNOP_PREINCREMENT
, PREC_PREFIX
, 0},
757 {"--", UNOP_PREDECREMENT
, PREC_PREFIX
, 0},
758 {NULL
, OP_NULL
, PREC_PREFIX
, 0}
761 enum c_primitive_types
{
762 c_primitive_type_int
,
763 c_primitive_type_long
,
764 c_primitive_type_short
,
765 c_primitive_type_char
,
766 c_primitive_type_float
,
767 c_primitive_type_double
,
768 c_primitive_type_void
,
769 c_primitive_type_long_long
,
770 c_primitive_type_signed_char
,
771 c_primitive_type_unsigned_char
,
772 c_primitive_type_unsigned_short
,
773 c_primitive_type_unsigned_int
,
774 c_primitive_type_unsigned_long
,
775 c_primitive_type_unsigned_long_long
,
776 c_primitive_type_long_double
,
777 c_primitive_type_complex
,
778 c_primitive_type_double_complex
,
779 c_primitive_type_decfloat
,
780 c_primitive_type_decdouble
,
781 c_primitive_type_declong
,
786 c_language_arch_info (struct gdbarch
*gdbarch
,
787 struct language_arch_info
*lai
)
789 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
791 lai
->string_char_type
= builtin
->builtin_char
;
792 lai
->primitive_type_vector
793 = GDBARCH_OBSTACK_CALLOC (gdbarch
, nr_c_primitive_types
+ 1,
795 lai
->primitive_type_vector
[c_primitive_type_int
] = builtin
->builtin_int
;
796 lai
->primitive_type_vector
[c_primitive_type_long
] = builtin
->builtin_long
;
797 lai
->primitive_type_vector
[c_primitive_type_short
] = builtin
->builtin_short
;
798 lai
->primitive_type_vector
[c_primitive_type_char
] = builtin
->builtin_char
;
799 lai
->primitive_type_vector
[c_primitive_type_float
] = builtin
->builtin_float
;
800 lai
->primitive_type_vector
[c_primitive_type_double
] = builtin
->builtin_double
;
801 lai
->primitive_type_vector
[c_primitive_type_void
] = builtin
->builtin_void
;
802 lai
->primitive_type_vector
[c_primitive_type_long_long
] = builtin
->builtin_long_long
;
803 lai
->primitive_type_vector
[c_primitive_type_signed_char
] = builtin
->builtin_signed_char
;
804 lai
->primitive_type_vector
[c_primitive_type_unsigned_char
] = builtin
->builtin_unsigned_char
;
805 lai
->primitive_type_vector
[c_primitive_type_unsigned_short
] = builtin
->builtin_unsigned_short
;
806 lai
->primitive_type_vector
[c_primitive_type_unsigned_int
] = builtin
->builtin_unsigned_int
;
807 lai
->primitive_type_vector
[c_primitive_type_unsigned_long
] = builtin
->builtin_unsigned_long
;
808 lai
->primitive_type_vector
[c_primitive_type_unsigned_long_long
] = builtin
->builtin_unsigned_long_long
;
809 lai
->primitive_type_vector
[c_primitive_type_long_double
] = builtin
->builtin_long_double
;
810 lai
->primitive_type_vector
[c_primitive_type_complex
] = builtin
->builtin_complex
;
811 lai
->primitive_type_vector
[c_primitive_type_double_complex
] = builtin
->builtin_double_complex
;
812 lai
->primitive_type_vector
[c_primitive_type_decfloat
] = builtin
->builtin_decfloat
;
813 lai
->primitive_type_vector
[c_primitive_type_decdouble
] = builtin
->builtin_decdouble
;
814 lai
->primitive_type_vector
[c_primitive_type_declong
] = builtin
->builtin_declong
;
816 lai
->bool_type_default
= builtin
->builtin_int
;
819 const struct exp_descriptor exp_descriptor_c
=
821 print_subexp_standard
,
822 operator_length_standard
,
823 operator_check_standard
,
825 dump_subexp_body_standard
,
829 static const char *c_extensions
[] =
834 extern const struct language_defn c_language_defn
=
836 "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 */
994 c_printchar
, /* Print a character constant */
995 c_printstr
, /* Function to print string constant */
996 c_emit_char
, /* Print a single char */
997 c_print_type
, /* Print a type using appropriate syntax */
998 c_print_typedef
, /* Print a typedef using appropriate syntax */
999 c_val_print
, /* Print a value using appropriate syntax */
1000 c_value_print
, /* Print a top-level value */
1001 default_read_var_value
, /* la_read_var_value */
1002 cplus_skip_trampoline
, /* Language specific skip_trampoline */
1003 "this", /* name_of_this */
1004 false, /* la_store_sym_names_in_linkage_form_p */
1005 cp_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
1006 cp_lookup_transparent_type
, /* lookup_transparent_type */
1007 gdb_demangle
, /* Language specific symbol demangler */
1008 gdb_sniff_from_mangled_name
,
1009 cp_class_name_from_physname
, /* Language specific
1010 class_name_from_physname */
1011 c_op_print_tab
, /* expression operators for printing */
1012 1, /* c-style arrays */
1013 0, /* String lower bound */
1014 default_word_break_characters
,
1015 default_collect_symbol_completion_matches
,
1016 cplus_language_arch_info
,
1017 default_print_array_index
,
1018 cp_pass_by_reference
,
1020 c_watch_location_expression
,
1021 cp_get_symbol_name_matcher
,
1022 iterate_over_symbols
,
1023 cp_search_name_hash
,
1030 static const char *asm_extensions
[] =
1032 ".s", ".sx", ".S", NULL
1035 extern const struct language_defn asm_language_defn
=
1037 "asm", /* Language name */
1049 c_printchar
, /* Print a character constant */
1050 c_printstr
, /* Function to print string constant */
1051 c_emit_char
, /* Print a single char */
1052 c_print_type
, /* Print a type using appropriate syntax */
1053 c_print_typedef
, /* Print a typedef using appropriate syntax */
1054 c_val_print
, /* Print a value using appropriate syntax */
1055 c_value_print
, /* Print a top-level value */
1056 default_read_var_value
, /* la_read_var_value */
1057 NULL
, /* Language specific skip_trampoline */
1058 NULL
, /* name_of_this */
1059 true, /* la_store_sym_names_in_linkage_form_p */
1060 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
1061 basic_lookup_transparent_type
,/* lookup_transparent_type */
1062 NULL
, /* Language specific symbol demangler */
1064 NULL
, /* Language specific
1065 class_name_from_physname */
1066 c_op_print_tab
, /* expression operators for printing */
1067 1, /* c-style arrays */
1068 0, /* String lower bound */
1069 default_word_break_characters
,
1070 default_collect_symbol_completion_matches
,
1071 c_language_arch_info
, /* FIXME: la_language_arch_info. */
1072 default_print_array_index
,
1073 default_pass_by_reference
,
1075 c_watch_location_expression
,
1076 NULL
, /* la_get_symbol_name_matcher */
1077 iterate_over_symbols
,
1078 default_search_name_hash
,
1079 &default_varobj_ops
,
1085 /* The following language_defn does not represent a real language.
1086 It just provides a minimal support a-la-C that should allow users
1087 to do some simple operations when debugging applications that use
1088 a language currently not supported by GDB. */
1090 extern const struct language_defn minimal_language_defn
=
1092 "minimal", /* Language name */
1104 c_printchar
, /* Print a character constant */
1105 c_printstr
, /* Function to print string constant */
1106 c_emit_char
, /* Print a single char */
1107 c_print_type
, /* Print a type using appropriate syntax */
1108 c_print_typedef
, /* Print a typedef using appropriate syntax */
1109 c_val_print
, /* Print a value using appropriate syntax */
1110 c_value_print
, /* Print a top-level value */
1111 default_read_var_value
, /* la_read_var_value */
1112 NULL
, /* Language specific skip_trampoline */
1113 NULL
, /* name_of_this */
1114 true, /* la_store_sym_names_in_linkage_form_p */
1115 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
1116 basic_lookup_transparent_type
,/* lookup_transparent_type */
1117 NULL
, /* Language specific symbol demangler */
1119 NULL
, /* Language specific
1120 class_name_from_physname */
1121 c_op_print_tab
, /* expression operators for printing */
1122 1, /* c-style arrays */
1123 0, /* String lower bound */
1124 default_word_break_characters
,
1125 default_collect_symbol_completion_matches
,
1126 c_language_arch_info
,
1127 default_print_array_index
,
1128 default_pass_by_reference
,
1130 c_watch_location_expression
,
1131 NULL
, /* la_get_symbol_name_matcher */
1132 iterate_over_symbols
,
1133 default_search_name_hash
,
1134 &default_varobj_ops
,