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 */
847 c_printchar
, /* Print a character constant */
848 c_printstr
, /* Function to print string constant */
849 c_emit_char
, /* Print a single char */
850 c_print_type
, /* Print a type using appropriate syntax */
851 c_print_typedef
, /* Print a typedef using appropriate syntax */
852 c_val_print
, /* Print a value using appropriate syntax */
853 c_value_print
, /* Print a top-level value */
854 default_read_var_value
, /* la_read_var_value */
855 NULL
, /* Language specific skip_trampoline */
856 NULL
, /* name_of_this */
857 true, /* la_store_sym_names_in_linkage_form_p */
858 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
859 basic_lookup_transparent_type
,/* lookup_transparent_type */
860 NULL
, /* Language specific symbol demangler */
862 NULL
, /* Language specific
863 class_name_from_physname */
864 c_op_print_tab
, /* expression operators for printing */
865 1, /* c-style arrays */
866 0, /* String lower bound */
867 default_word_break_characters
,
868 default_collect_symbol_completion_matches
,
869 c_language_arch_info
,
870 default_print_array_index
,
871 default_pass_by_reference
,
873 c_watch_location_expression
,
874 NULL
, /* la_get_symbol_name_matcher */
875 iterate_over_symbols
,
876 default_search_name_hash
,
878 c_get_compile_context
,
883 enum cplus_primitive_types
{
884 cplus_primitive_type_int
,
885 cplus_primitive_type_long
,
886 cplus_primitive_type_short
,
887 cplus_primitive_type_char
,
888 cplus_primitive_type_float
,
889 cplus_primitive_type_double
,
890 cplus_primitive_type_void
,
891 cplus_primitive_type_long_long
,
892 cplus_primitive_type_signed_char
,
893 cplus_primitive_type_unsigned_char
,
894 cplus_primitive_type_unsigned_short
,
895 cplus_primitive_type_unsigned_int
,
896 cplus_primitive_type_unsigned_long
,
897 cplus_primitive_type_unsigned_long_long
,
898 cplus_primitive_type_long_double
,
899 cplus_primitive_type_complex
,
900 cplus_primitive_type_double_complex
,
901 cplus_primitive_type_bool
,
902 cplus_primitive_type_decfloat
,
903 cplus_primitive_type_decdouble
,
904 cplus_primitive_type_declong
,
905 cplus_primitive_type_char16_t
,
906 cplus_primitive_type_char32_t
,
907 cplus_primitive_type_wchar_t
,
908 nr_cplus_primitive_types
912 cplus_language_arch_info (struct gdbarch
*gdbarch
,
913 struct language_arch_info
*lai
)
915 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
917 lai
->string_char_type
= builtin
->builtin_char
;
918 lai
->primitive_type_vector
919 = GDBARCH_OBSTACK_CALLOC (gdbarch
, nr_cplus_primitive_types
+ 1,
921 lai
->primitive_type_vector
[cplus_primitive_type_int
]
922 = builtin
->builtin_int
;
923 lai
->primitive_type_vector
[cplus_primitive_type_long
]
924 = builtin
->builtin_long
;
925 lai
->primitive_type_vector
[cplus_primitive_type_short
]
926 = builtin
->builtin_short
;
927 lai
->primitive_type_vector
[cplus_primitive_type_char
]
928 = builtin
->builtin_char
;
929 lai
->primitive_type_vector
[cplus_primitive_type_float
]
930 = builtin
->builtin_float
;
931 lai
->primitive_type_vector
[cplus_primitive_type_double
]
932 = builtin
->builtin_double
;
933 lai
->primitive_type_vector
[cplus_primitive_type_void
]
934 = builtin
->builtin_void
;
935 lai
->primitive_type_vector
[cplus_primitive_type_long_long
]
936 = builtin
->builtin_long_long
;
937 lai
->primitive_type_vector
[cplus_primitive_type_signed_char
]
938 = builtin
->builtin_signed_char
;
939 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_char
]
940 = builtin
->builtin_unsigned_char
;
941 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_short
]
942 = builtin
->builtin_unsigned_short
;
943 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_int
]
944 = builtin
->builtin_unsigned_int
;
945 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_long
]
946 = builtin
->builtin_unsigned_long
;
947 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_long_long
]
948 = builtin
->builtin_unsigned_long_long
;
949 lai
->primitive_type_vector
[cplus_primitive_type_long_double
]
950 = builtin
->builtin_long_double
;
951 lai
->primitive_type_vector
[cplus_primitive_type_complex
]
952 = builtin
->builtin_complex
;
953 lai
->primitive_type_vector
[cplus_primitive_type_double_complex
]
954 = builtin
->builtin_double_complex
;
955 lai
->primitive_type_vector
[cplus_primitive_type_bool
]
956 = builtin
->builtin_bool
;
957 lai
->primitive_type_vector
[cplus_primitive_type_decfloat
]
958 = builtin
->builtin_decfloat
;
959 lai
->primitive_type_vector
[cplus_primitive_type_decdouble
]
960 = builtin
->builtin_decdouble
;
961 lai
->primitive_type_vector
[cplus_primitive_type_declong
]
962 = builtin
->builtin_declong
;
963 lai
->primitive_type_vector
[cplus_primitive_type_char16_t
]
964 = builtin
->builtin_char16
;
965 lai
->primitive_type_vector
[cplus_primitive_type_char32_t
]
966 = builtin
->builtin_char32
;
967 lai
->primitive_type_vector
[cplus_primitive_type_wchar_t
]
968 = builtin
->builtin_wchar
;
970 lai
->bool_type_symbol
= "bool";
971 lai
->bool_type_default
= builtin
->builtin_bool
;
974 static const char *cplus_extensions
[] =
976 ".C", ".cc", ".cp", ".cpp", ".cxx", ".c++", NULL
979 extern const struct language_defn cplus_language_defn
=
981 "c++", /* Language name */
992 c_printchar
, /* Print a character constant */
993 c_printstr
, /* Function to print string constant */
994 c_emit_char
, /* Print a single char */
995 c_print_type
, /* Print a type using appropriate syntax */
996 c_print_typedef
, /* Print a typedef using appropriate syntax */
997 c_val_print
, /* Print a value using appropriate syntax */
998 c_value_print
, /* Print a top-level value */
999 default_read_var_value
, /* la_read_var_value */
1000 cplus_skip_trampoline
, /* Language specific skip_trampoline */
1001 "this", /* name_of_this */
1002 false, /* la_store_sym_names_in_linkage_form_p */
1003 cp_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
1004 cp_lookup_transparent_type
, /* lookup_transparent_type */
1005 gdb_demangle
, /* Language specific symbol demangler */
1006 gdb_sniff_from_mangled_name
,
1007 cp_class_name_from_physname
, /* Language specific
1008 class_name_from_physname */
1009 c_op_print_tab
, /* expression operators for printing */
1010 1, /* c-style arrays */
1011 0, /* String lower bound */
1012 default_word_break_characters
,
1013 default_collect_symbol_completion_matches
,
1014 cplus_language_arch_info
,
1015 default_print_array_index
,
1016 cp_pass_by_reference
,
1018 c_watch_location_expression
,
1019 cp_get_symbol_name_matcher
,
1020 iterate_over_symbols
,
1021 cp_search_name_hash
,
1028 static const char *asm_extensions
[] =
1030 ".s", ".sx", ".S", NULL
1033 extern const struct language_defn asm_language_defn
=
1035 "asm", /* Language name */
1046 c_printchar
, /* Print a character constant */
1047 c_printstr
, /* Function to print string constant */
1048 c_emit_char
, /* Print a single char */
1049 c_print_type
, /* Print a type using appropriate syntax */
1050 c_print_typedef
, /* Print a typedef using appropriate syntax */
1051 c_val_print
, /* Print a value using appropriate syntax */
1052 c_value_print
, /* Print a top-level value */
1053 default_read_var_value
, /* la_read_var_value */
1054 NULL
, /* Language specific skip_trampoline */
1055 NULL
, /* name_of_this */
1056 true, /* la_store_sym_names_in_linkage_form_p */
1057 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
1058 basic_lookup_transparent_type
,/* lookup_transparent_type */
1059 NULL
, /* Language specific symbol demangler */
1061 NULL
, /* Language specific
1062 class_name_from_physname */
1063 c_op_print_tab
, /* expression operators for printing */
1064 1, /* c-style arrays */
1065 0, /* String lower bound */
1066 default_word_break_characters
,
1067 default_collect_symbol_completion_matches
,
1068 c_language_arch_info
, /* FIXME: la_language_arch_info. */
1069 default_print_array_index
,
1070 default_pass_by_reference
,
1072 c_watch_location_expression
,
1073 NULL
, /* la_get_symbol_name_matcher */
1074 iterate_over_symbols
,
1075 default_search_name_hash
,
1076 &default_varobj_ops
,
1082 /* The following language_defn does not represent a real language.
1083 It just provides a minimal support a-la-C that should allow users
1084 to do some simple operations when debugging applications that use
1085 a language currently not supported by GDB. */
1087 extern const struct language_defn minimal_language_defn
=
1089 "minimal", /* Language name */
1100 c_printchar
, /* Print a character constant */
1101 c_printstr
, /* Function to print string constant */
1102 c_emit_char
, /* Print a single char */
1103 c_print_type
, /* Print a type using appropriate syntax */
1104 c_print_typedef
, /* Print a typedef using appropriate syntax */
1105 c_val_print
, /* Print a value using appropriate syntax */
1106 c_value_print
, /* Print a top-level value */
1107 default_read_var_value
, /* la_read_var_value */
1108 NULL
, /* Language specific skip_trampoline */
1109 NULL
, /* name_of_this */
1110 true, /* la_store_sym_names_in_linkage_form_p */
1111 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
1112 basic_lookup_transparent_type
,/* lookup_transparent_type */
1113 NULL
, /* Language specific symbol demangler */
1115 NULL
, /* Language specific
1116 class_name_from_physname */
1117 c_op_print_tab
, /* expression operators for printing */
1118 1, /* c-style arrays */
1119 0, /* String lower bound */
1120 default_word_break_characters
,
1121 default_collect_symbol_completion_matches
,
1122 c_language_arch_info
,
1123 default_print_array_index
,
1124 default_pass_by_reference
,
1126 c_watch_location_expression
,
1127 NULL
, /* la_get_symbol_name_matcher */
1128 iterate_over_symbols
,
1129 default_search_name_hash
,
1130 &default_varobj_ops
,