1 /* C language support routines for GDB, the GNU debugger.
3 Copyright (C) 1992-2017 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"
29 #include "macroscope.h"
33 #include "cp-support.h"
34 #include "gdb_obstack.h"
38 extern void _initialize_c_language (void);
40 /* Given a C string type, STR_TYPE, return the corresponding target
41 character set name. */
44 charset_for_string_type (c_string_type str_type, struct gdbarch *gdbarch)
46 switch (str_type & ~C_CHAR)
49 return target_charset (gdbarch);
51 return target_wide_charset (gdbarch);
53 /* FIXME: UTF-16 is not always correct. */
54 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
59 /* FIXME: UTF-32 is not always correct. */
60 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
65 internal_error (__FILE__, __LINE__, _("unhandled c_string_type"));
68 /* Classify ELTTYPE according to what kind of character it is. Return
69 the enum constant representing the character type. Also set
70 *ENCODING to the name of the character set to use when converting
71 characters of this type in target BYTE_ORDER to the host character
75 classify_type (struct type *elttype, struct gdbarch *gdbarch,
76 const char **encoding)
80 /* We loop because ELTTYPE may be a typedef, and we want to
81 successively peel each typedef until we reach a type we
82 understand. We don't use CHECK_TYPEDEF because that will strip
83 all typedefs at once -- but in C, wchar_t is itself a typedef, so
84 that would do the wrong thing. */
87 const char *name = TYPE_NAME (elttype);
89 if (TYPE_CODE (elttype) == TYPE_CODE_CHAR || !name)
95 if (!strcmp (name, "wchar_t"))
101 if (!strcmp (name, "char16_t"))
107 if (!strcmp (name, "char32_t"))
113 if (TYPE_CODE (elttype) != TYPE_CODE_TYPEDEF)
116 /* Call for side effects. */
117 check_typedef (elttype);
119 if (TYPE_TARGET_TYPE (elttype))
120 elttype = TYPE_TARGET_TYPE (elttype);
123 /* Perhaps check_typedef did not update the target type. In
124 this case, force the lookup again and hope it works out.
125 It never will for C, but it might for C++. */
126 elttype = check_typedef (elttype);
135 *encoding = charset_for_string_type (result, gdbarch);
140 /* Print the character C on STREAM as part of the contents of a
141 literal string whose delimiter is QUOTER. Note that that format
142 for printing characters and strings is language specific. */
145 c_emit_char (int c, struct type *type,
146 struct ui_file *stream, int quoter)
148 const char *encoding;
150 classify_type (type, get_type_arch (type), &encoding);
151 generic_emit_char (c, type, stream, quoter, encoding);
155 c_printchar (int c, struct type *type, struct ui_file *stream)
157 c_string_type str_type;
159 str_type = classify_type (type, get_type_arch (type), NULL);
165 fputc_filtered ('L', stream);
168 fputc_filtered ('u', stream);
171 fputc_filtered ('U', stream);
175 fputc_filtered ('\'', stream);
176 LA_EMIT_CHAR (c, type, stream, '\'');
177 fputc_filtered ('\'', stream);
180 /* Print the character string STRING, printing at most LENGTH
181 characters. LENGTH is -1 if the string is nul terminated. Each
182 character is WIDTH bytes long. Printing stops early if the number
183 hits print_max; repeat counts are printed as appropriate. Print
184 ellipses at the end if we had to stop before printing LENGTH
185 characters, or if FORCE_ELLIPSES. */
188 c_printstr (struct ui_file *stream, struct type *type,
189 const gdb_byte *string, unsigned int length,
190 const char *user_encoding, int force_ellipses,
191 const struct value_print_options *options)
193 c_string_type str_type;
194 const char *type_encoding;
195 const char *encoding;
197 str_type = (classify_type (type, get_type_arch (type), &type_encoding)
204 fputs_filtered ("L", stream);
207 fputs_filtered ("u", stream);
210 fputs_filtered ("U", stream);
214 encoding = (user_encoding && *user_encoding) ? user_encoding : type_encoding;
216 generic_printstr (stream, type, string, length, encoding, force_ellipses,
220 /* Obtain a C string from the inferior storing it in a newly allocated
221 buffer in BUFFER, which should be freed by the caller. If the in-
222 and out-parameter *LENGTH is specified at -1, the string is read
223 until a null character of the appropriate width is found, otherwise
224 the string is read to the length of characters specified. The size
225 of a character is determined by the length of the target type of
226 the pointer or array.
228 If VALUE is an array with a known length, and *LENGTH is -1,
229 the function will not read past the end of the array. However, any
230 declared size of the array is ignored if *LENGTH > 0.
232 On completion, *LENGTH will be set to the size of the string read in
233 characters. (If a length of -1 is specified, the length returned
234 will not include the null character). CHARSET is always set to the
238 c_get_string (struct value *value, gdb_byte **buffer,
239 int *length, struct type **char_type,
240 const char **charset)
243 unsigned int fetchlimit;
244 struct type *type = check_typedef (value_type (value));
245 struct type *element_type = TYPE_TARGET_TYPE (type);
246 int req_length = *length;
247 enum bfd_endian byte_order
248 = gdbarch_byte_order (get_type_arch (type));
250 if (element_type == NULL)
253 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
255 /* If we know the size of the array, we can use it as a limit on
256 the number of characters to be fetched. */
257 if (TYPE_NFIELDS (type) == 1
258 && TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_RANGE)
260 LONGEST low_bound, high_bound;
262 get_discrete_bounds (TYPE_FIELD_TYPE (type, 0),
263 &low_bound, &high_bound);
264 fetchlimit = high_bound - low_bound + 1;
267 fetchlimit = UINT_MAX;
269 else if (TYPE_CODE (type) == TYPE_CODE_PTR)
270 fetchlimit = UINT_MAX;
272 /* We work only with arrays and pointers. */
275 if (! c_textual_element_type (element_type, 0))
277 classify_type (element_type, get_type_arch (element_type), charset);
278 width = TYPE_LENGTH (element_type);
280 /* If the string lives in GDB's memory instead of the inferior's,
281 then we just need to copy it to BUFFER. Also, since such strings
282 are arrays with known size, FETCHLIMIT will hold the size of the
284 if ((VALUE_LVAL (value) == not_lval
285 || VALUE_LVAL (value) == lval_internalvar)
286 && fetchlimit != UINT_MAX)
289 const gdb_byte *contents = value_contents (value);
291 /* If a length is specified, use that. */
295 /* Otherwise, look for a null character. */
296 for (i = 0; i < fetchlimit; i++)
297 if (extract_unsigned_integer (contents + i * width,
298 width, byte_order) == 0)
301 /* I is now either a user-defined length, the number of non-null
302 characters, or FETCHLIMIT. */
304 *buffer = (gdb_byte *) xmalloc (*length);
305 memcpy (*buffer, contents, *length);
310 CORE_ADDR addr = value_as_address (value);
312 /* Prior to the fix for PR 16196 read_string would ignore fetchlimit
313 if length > 0. The old "broken" behaviour is the behaviour we want:
314 The caller may want to fetch 100 bytes from a variable length array
315 implemented using the common idiom of having an array of length 1 at
316 the end of a struct. In this case we want to ignore the declared
317 size of the array. However, it's counterintuitive to implement that
318 behaviour in read_string: what does fetchlimit otherwise mean if
319 length > 0. Therefore we implement the behaviour we want here:
320 If *length > 0, don't specify a fetchlimit. This preserves the
321 previous behaviour. We could move this check above where we know
322 whether the array is declared with a fixed size, but we only want
323 to apply this behaviour when calling read_string. PR 16286. */
325 fetchlimit = UINT_MAX;
327 err = read_string (addr, *length, width, fetchlimit,
328 byte_order, buffer, length);
332 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 + *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 obstack output;
574 struct cleanup *cleanup;
575 struct value *result;
576 c_string_type dest_type;
577 const char *dest_charset;
578 int satisfy_expected = 0;
580 obstack_init (&output);
581 cleanup = make_cleanup_obstack_free (&output);
584 oplen = longest_to_int (exp->elts[*pos].longconst);
587 limit = *pos + BYTES_TO_EXP_ELEM (oplen + 1);
588 dest_type = ((enum c_string_type_values)
589 longest_to_int (exp->elts[*pos].longconst));
590 switch (dest_type & ~C_CHAR)
593 type = language_string_char_type (exp->language_defn,
597 type = lookup_typename (exp->language_defn, exp->gdbarch,
601 type = lookup_typename (exp->language_defn, exp->gdbarch,
602 "char16_t", NULL, 0);
605 type = lookup_typename (exp->language_defn, exp->gdbarch,
606 "char32_t", NULL, 0);
609 internal_error (__FILE__, __LINE__, _("unhandled c_string_type"));
612 /* Ensure TYPE_LENGTH is valid for TYPE. */
613 check_typedef (type);
615 /* If the caller expects an array of some integral type,
616 satisfy them. If something odder is expected, rely on the
618 if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_ARRAY)
620 struct type *element_type
621 = check_typedef (TYPE_TARGET_TYPE (expect_type));
623 if (TYPE_CODE (element_type) == TYPE_CODE_INT
624 || TYPE_CODE (element_type) == TYPE_CODE_CHAR)
627 satisfy_expected = 1;
631 dest_charset = charset_for_string_type (dest_type, exp->gdbarch);
638 len = longest_to_int (exp->elts[*pos].longconst);
641 if (noside != EVAL_SKIP)
642 parse_one_string (&output, &exp->elts[*pos].string, len,
644 *pos += BYTES_TO_EXP_ELEM (len);
647 /* Skip the trailing length and opcode. */
650 if (noside == EVAL_SKIP)
652 /* Return a dummy value of the appropriate type. */
653 if (expect_type != NULL)
654 result = allocate_value (expect_type);
655 else if ((dest_type & C_CHAR) != 0)
656 result = allocate_value (type);
658 result = value_cstring ("", 0, type);
659 do_cleanups (cleanup);
663 if ((dest_type & C_CHAR) != 0)
667 if (obstack_object_size (&output) != TYPE_LENGTH (type))
668 error (_("Could not convert character "
669 "constant to target character set"));
670 value = unpack_long (type, (gdb_byte *) obstack_base (&output));
671 result = value_from_longest (type, value);
677 /* Write the terminating character. */
678 for (i = 0; i < TYPE_LENGTH (type); ++i)
679 obstack_1grow (&output, 0);
681 if (satisfy_expected)
683 LONGEST low_bound, high_bound;
684 int element_size = TYPE_LENGTH (type);
686 if (get_discrete_bounds (TYPE_INDEX_TYPE (expect_type),
687 &low_bound, &high_bound) < 0)
690 high_bound = (TYPE_LENGTH (expect_type) / element_size) - 1;
692 if (obstack_object_size (&output) / element_size
693 > (high_bound - low_bound + 1))
694 error (_("Too many array elements"));
696 result = allocate_value (expect_type);
697 memcpy (value_contents_raw (result), obstack_base (&output),
698 obstack_object_size (&output));
701 result = value_cstring ((const char *) obstack_base (&output),
702 obstack_object_size (&output),
705 do_cleanups (cleanup);
713 return evaluate_subexp_standard (expect_type, exp, pos, noside);
716 /* la_watch_location_expression for C. */
718 gdb::unique_xmalloc_ptr<char>
719 c_watch_location_expression (struct type *type, CORE_ADDR addr)
721 type = check_typedef (TYPE_TARGET_TYPE (check_typedef (type)));
722 std::string name = type_to_string (type);
723 return gdb::unique_xmalloc_ptr<char>
724 (xstrprintf ("* (%s *) %s", name.c_str (), core_addr_to_string (addr)));
728 /* Table mapping opcodes into strings for printing operators
729 and precedences of the operators. */
731 const struct op_print c_op_print_tab[] =
733 {",", BINOP_COMMA, PREC_COMMA, 0},
734 {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
735 {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
736 {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
737 {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
738 {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
739 {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
740 {"==", BINOP_EQUAL, PREC_EQUAL, 0},
741 {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
742 {"<=", BINOP_LEQ, PREC_ORDER, 0},
743 {">=", BINOP_GEQ, PREC_ORDER, 0},
744 {">", BINOP_GTR, PREC_ORDER, 0},
745 {"<", BINOP_LESS, PREC_ORDER, 0},
746 {">>", BINOP_RSH, PREC_SHIFT, 0},
747 {"<<", BINOP_LSH, PREC_SHIFT, 0},
748 {"+", BINOP_ADD, PREC_ADD, 0},
749 {"-", BINOP_SUB, PREC_ADD, 0},
750 {"*", BINOP_MUL, PREC_MUL, 0},
751 {"/", BINOP_DIV, PREC_MUL, 0},
752 {"%", BINOP_REM, PREC_MUL, 0},
753 {"@", BINOP_REPEAT, PREC_REPEAT, 0},
754 {"+", UNOP_PLUS, PREC_PREFIX, 0},
755 {"-", UNOP_NEG, PREC_PREFIX, 0},
756 {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
757 {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
758 {"*", UNOP_IND, PREC_PREFIX, 0},
759 {"&", UNOP_ADDR, PREC_PREFIX, 0},
760 {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
761 {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
762 {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
763 {NULL, OP_NULL, PREC_PREFIX, 0}
766 enum c_primitive_types {
767 c_primitive_type_int,
768 c_primitive_type_long,
769 c_primitive_type_short,
770 c_primitive_type_char,
771 c_primitive_type_float,
772 c_primitive_type_double,
773 c_primitive_type_void,
774 c_primitive_type_long_long,
775 c_primitive_type_signed_char,
776 c_primitive_type_unsigned_char,
777 c_primitive_type_unsigned_short,
778 c_primitive_type_unsigned_int,
779 c_primitive_type_unsigned_long,
780 c_primitive_type_unsigned_long_long,
781 c_primitive_type_long_double,
782 c_primitive_type_complex,
783 c_primitive_type_double_complex,
784 c_primitive_type_decfloat,
785 c_primitive_type_decdouble,
786 c_primitive_type_declong,
791 c_language_arch_info (struct gdbarch *gdbarch,
792 struct language_arch_info *lai)
794 const struct builtin_type *builtin = builtin_type (gdbarch);
796 lai->string_char_type = builtin->builtin_char;
797 lai->primitive_type_vector
798 = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_c_primitive_types + 1,
800 lai->primitive_type_vector [c_primitive_type_int] = builtin->builtin_int;
801 lai->primitive_type_vector [c_primitive_type_long] = builtin->builtin_long;
802 lai->primitive_type_vector [c_primitive_type_short] = builtin->builtin_short;
803 lai->primitive_type_vector [c_primitive_type_char] = builtin->builtin_char;
804 lai->primitive_type_vector [c_primitive_type_float] = builtin->builtin_float;
805 lai->primitive_type_vector [c_primitive_type_double] = builtin->builtin_double;
806 lai->primitive_type_vector [c_primitive_type_void] = builtin->builtin_void;
807 lai->primitive_type_vector [c_primitive_type_long_long] = builtin->builtin_long_long;
808 lai->primitive_type_vector [c_primitive_type_signed_char] = builtin->builtin_signed_char;
809 lai->primitive_type_vector [c_primitive_type_unsigned_char] = builtin->builtin_unsigned_char;
810 lai->primitive_type_vector [c_primitive_type_unsigned_short] = builtin->builtin_unsigned_short;
811 lai->primitive_type_vector [c_primitive_type_unsigned_int] = builtin->builtin_unsigned_int;
812 lai->primitive_type_vector [c_primitive_type_unsigned_long] = builtin->builtin_unsigned_long;
813 lai->primitive_type_vector [c_primitive_type_unsigned_long_long] = builtin->builtin_unsigned_long_long;
814 lai->primitive_type_vector [c_primitive_type_long_double] = builtin->builtin_long_double;
815 lai->primitive_type_vector [c_primitive_type_complex] = builtin->builtin_complex;
816 lai->primitive_type_vector [c_primitive_type_double_complex] = builtin->builtin_double_complex;
817 lai->primitive_type_vector [c_primitive_type_decfloat] = builtin->builtin_decfloat;
818 lai->primitive_type_vector [c_primitive_type_decdouble] = builtin->builtin_decdouble;
819 lai->primitive_type_vector [c_primitive_type_declong] = builtin->builtin_declong;
821 lai->bool_type_default = builtin->builtin_int;
824 const struct exp_descriptor exp_descriptor_c =
826 print_subexp_standard,
827 operator_length_standard,
828 operator_check_standard,
830 dump_subexp_body_standard,
834 static const char *c_extensions[] =
839 const struct language_defn c_language_defn =
841 "c", /* Language name */
853 c_printchar, /* Print a character constant */
854 c_printstr, /* Function to print string constant */
855 c_emit_char, /* Print a single char */
856 c_print_type, /* Print a type using appropriate syntax */
857 c_print_typedef, /* Print a typedef using appropriate syntax */
858 c_val_print, /* Print a value using appropriate syntax */
859 c_value_print, /* Print a top-level value */
860 default_read_var_value, /* la_read_var_value */
861 NULL, /* Language specific skip_trampoline */
862 NULL, /* name_of_this */
863 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
864 basic_lookup_transparent_type,/* lookup_transparent_type */
865 NULL, /* Language specific symbol demangler */
867 NULL, /* Language specific
868 class_name_from_physname */
869 c_op_print_tab, /* expression operators for printing */
870 1, /* c-style arrays */
871 0, /* String lower bound */
872 default_word_break_characters,
873 default_make_symbol_completion_list,
874 c_language_arch_info,
875 default_print_array_index,
876 default_pass_by_reference,
878 c_watch_location_expression,
879 NULL, /* la_get_symbol_name_cmp */
880 iterate_over_symbols,
882 c_get_compile_context,
887 enum cplus_primitive_types {
888 cplus_primitive_type_int,
889 cplus_primitive_type_long,
890 cplus_primitive_type_short,
891 cplus_primitive_type_char,
892 cplus_primitive_type_float,
893 cplus_primitive_type_double,
894 cplus_primitive_type_void,
895 cplus_primitive_type_long_long,
896 cplus_primitive_type_signed_char,
897 cplus_primitive_type_unsigned_char,
898 cplus_primitive_type_unsigned_short,
899 cplus_primitive_type_unsigned_int,
900 cplus_primitive_type_unsigned_long,
901 cplus_primitive_type_unsigned_long_long,
902 cplus_primitive_type_long_double,
903 cplus_primitive_type_complex,
904 cplus_primitive_type_double_complex,
905 cplus_primitive_type_bool,
906 cplus_primitive_type_decfloat,
907 cplus_primitive_type_decdouble,
908 cplus_primitive_type_declong,
909 cplus_primitive_type_char16_t,
910 cplus_primitive_type_char32_t,
911 cplus_primitive_type_wchar_t,
912 nr_cplus_primitive_types
916 cplus_language_arch_info (struct gdbarch *gdbarch,
917 struct language_arch_info *lai)
919 const struct builtin_type *builtin = builtin_type (gdbarch);
921 lai->string_char_type = builtin->builtin_char;
922 lai->primitive_type_vector
923 = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_cplus_primitive_types + 1,
925 lai->primitive_type_vector [cplus_primitive_type_int]
926 = builtin->builtin_int;
927 lai->primitive_type_vector [cplus_primitive_type_long]
928 = builtin->builtin_long;
929 lai->primitive_type_vector [cplus_primitive_type_short]
930 = builtin->builtin_short;
931 lai->primitive_type_vector [cplus_primitive_type_char]
932 = builtin->builtin_char;
933 lai->primitive_type_vector [cplus_primitive_type_float]
934 = builtin->builtin_float;
935 lai->primitive_type_vector [cplus_primitive_type_double]
936 = builtin->builtin_double;
937 lai->primitive_type_vector [cplus_primitive_type_void]
938 = builtin->builtin_void;
939 lai->primitive_type_vector [cplus_primitive_type_long_long]
940 = builtin->builtin_long_long;
941 lai->primitive_type_vector [cplus_primitive_type_signed_char]
942 = builtin->builtin_signed_char;
943 lai->primitive_type_vector [cplus_primitive_type_unsigned_char]
944 = builtin->builtin_unsigned_char;
945 lai->primitive_type_vector [cplus_primitive_type_unsigned_short]
946 = builtin->builtin_unsigned_short;
947 lai->primitive_type_vector [cplus_primitive_type_unsigned_int]
948 = builtin->builtin_unsigned_int;
949 lai->primitive_type_vector [cplus_primitive_type_unsigned_long]
950 = builtin->builtin_unsigned_long;
951 lai->primitive_type_vector [cplus_primitive_type_unsigned_long_long]
952 = builtin->builtin_unsigned_long_long;
953 lai->primitive_type_vector [cplus_primitive_type_long_double]
954 = builtin->builtin_long_double;
955 lai->primitive_type_vector [cplus_primitive_type_complex]
956 = builtin->builtin_complex;
957 lai->primitive_type_vector [cplus_primitive_type_double_complex]
958 = builtin->builtin_double_complex;
959 lai->primitive_type_vector [cplus_primitive_type_bool]
960 = builtin->builtin_bool;
961 lai->primitive_type_vector [cplus_primitive_type_decfloat]
962 = builtin->builtin_decfloat;
963 lai->primitive_type_vector [cplus_primitive_type_decdouble]
964 = builtin->builtin_decdouble;
965 lai->primitive_type_vector [cplus_primitive_type_declong]
966 = builtin->builtin_declong;
967 lai->primitive_type_vector [cplus_primitive_type_char16_t]
968 = builtin->builtin_char16;
969 lai->primitive_type_vector [cplus_primitive_type_char32_t]
970 = builtin->builtin_char32;
971 lai->primitive_type_vector [cplus_primitive_type_wchar_t]
972 = builtin->builtin_wchar;
974 lai->bool_type_symbol = "bool";
975 lai->bool_type_default = builtin->builtin_bool;
978 static const char *cplus_extensions[] =
980 ".C", ".cc", ".cp", ".cpp", ".cxx", ".c++", NULL
983 const struct language_defn cplus_language_defn =
985 "c++", /* Language name */
997 c_printchar, /* Print a character constant */
998 c_printstr, /* Function to print string constant */
999 c_emit_char, /* Print a single char */
1000 c_print_type, /* Print a type using appropriate syntax */
1001 c_print_typedef, /* Print a typedef using appropriate syntax */
1002 c_val_print, /* Print a value using appropriate syntax */
1003 c_value_print, /* Print a top-level value */
1004 default_read_var_value, /* la_read_var_value */
1005 cplus_skip_trampoline, /* Language specific skip_trampoline */
1006 "this", /* name_of_this */
1007 cp_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1008 cp_lookup_transparent_type, /* lookup_transparent_type */
1009 gdb_demangle, /* Language specific symbol demangler */
1010 gdb_sniff_from_mangled_name,
1011 cp_class_name_from_physname, /* Language specific
1012 class_name_from_physname */
1013 c_op_print_tab, /* expression operators for printing */
1014 1, /* c-style arrays */
1015 0, /* String lower bound */
1016 default_word_break_characters,
1017 default_make_symbol_completion_list,
1018 cplus_language_arch_info,
1019 default_print_array_index,
1020 cp_pass_by_reference,
1022 c_watch_location_expression,
1023 NULL, /* la_get_symbol_name_cmp */
1024 iterate_over_symbols,
1031 static const char *asm_extensions[] =
1033 ".s", ".sx", ".S", NULL
1036 const struct language_defn asm_language_defn =
1038 "asm", /* Language name */
1050 c_printchar, /* Print a character constant */
1051 c_printstr, /* Function to print string constant */
1052 c_emit_char, /* Print a single char */
1053 c_print_type, /* Print a type using appropriate syntax */
1054 c_print_typedef, /* Print a typedef using appropriate syntax */
1055 c_val_print, /* Print a value using appropriate syntax */
1056 c_value_print, /* Print a top-level value */
1057 default_read_var_value, /* la_read_var_value */
1058 NULL, /* Language specific skip_trampoline */
1059 NULL, /* name_of_this */
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_make_symbol_completion_list,
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_cmp */
1077 iterate_over_symbols,
1078 &default_varobj_ops,
1084 /* The following language_defn does not represent a real language.
1085 It just provides a minimal support a-la-C that should allow users
1086 to do some simple operations when debugging applications that use
1087 a language currently not supported by GDB. */
1089 const struct language_defn minimal_language_defn =
1091 "minimal", /* Language name */
1103 c_printchar, /* Print a character constant */
1104 c_printstr, /* Function to print string constant */
1105 c_emit_char, /* Print a single char */
1106 c_print_type, /* Print a type using appropriate syntax */
1107 c_print_typedef, /* Print a typedef using appropriate syntax */
1108 c_val_print, /* Print a value using appropriate syntax */
1109 c_value_print, /* Print a top-level value */
1110 default_read_var_value, /* la_read_var_value */
1111 NULL, /* Language specific skip_trampoline */
1112 NULL, /* name_of_this */
1113 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1114 basic_lookup_transparent_type,/* lookup_transparent_type */
1115 NULL, /* Language specific symbol demangler */
1117 NULL, /* Language specific
1118 class_name_from_physname */
1119 c_op_print_tab, /* expression operators for printing */
1120 1, /* c-style arrays */
1121 0, /* String lower bound */
1122 default_word_break_characters,
1123 default_make_symbol_completion_list,
1124 c_language_arch_info,
1125 default_print_array_index,
1126 default_pass_by_reference,
1128 c_watch_location_expression,
1129 NULL, /* la_get_symbol_name_cmp */
1130 iterate_over_symbols,
1131 &default_varobj_ops,
1138 _initialize_c_language (void)
1140 add_language (&c_language_defn);
1141 add_language (&cplus_language_defn);
1142 add_language (&asm_language_defn);
1143 add_language (&minimal_language_defn);