projects / deliverable / binutils-gdb.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Add initial type alignment support
[deliverable/binutils-gdb.git] / gdb / c-lang.c
... / ...
CommitLineData
1/* C language support routines for GDB, the GNU debugger.
2
3 Copyright (C) 1992-2018 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
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.
11
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.
16
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/>. */
19
20#include "defs.h"
21#include "symtab.h"
22#include "gdbtypes.h"
23#include "expression.h"
24#include "parser-defs.h"
25#include "language.h"
26#include "varobj.h"
27#include "c-lang.h"
28#include "valprint.h"
29#include "macroscope.h"
30#include "charset.h"
31#include "demangle.h"
32#include "cp-abi.h"
33#include "cp-support.h"
34#include "gdb_obstack.h"
35#include <ctype.h>
36#include "gdbcore.h"
37
38/* Given a C string type, STR_TYPE, return the corresponding target
39 character set name. */
40
41static const char *
42charset_for_string_type (c_string_type str_type, struct gdbarch *gdbarch)
43{
44 switch (str_type & ~C_CHAR)
45 {
46 case C_STRING:
47 return target_charset (gdbarch);
48 case C_WIDE_STRING:
49 return target_wide_charset (gdbarch);
50 case C_STRING_16:
51 /* FIXME: UTF-16 is not always correct. */
52 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
53 return "UTF-16BE";
54 else
55 return "UTF-16LE";
56 case C_STRING_32:
57 /* FIXME: UTF-32 is not always correct. */
58 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
59 return "UTF-32BE";
60 else
61 return "UTF-32LE";
62 }
63 internal_error (__FILE__, __LINE__, _("unhandled c_string_type"));
64}
65
66/* Classify ELTTYPE according to what kind of character it is. Return
67 the enum constant representing the character type. Also set
68 *ENCODING to the name of the character set to use when converting
69 characters of this type in target BYTE_ORDER to the host character
70 set. */
71
72static c_string_type
73classify_type (struct type *elttype, struct gdbarch *gdbarch,
74 const char **encoding)
75{
76 c_string_type result;
77
78 /* We loop because ELTTYPE may be a typedef, and we want to
79 successively peel each typedef until we reach a type we
80 understand. We don't use CHECK_TYPEDEF because that will strip
81 all typedefs at once -- but in C, wchar_t is itself a typedef, so
82 that would do the wrong thing. */
83 while (elttype)
84 {
85 const char *name = TYPE_NAME (elttype);
86
87 if (TYPE_CODE (elttype) == TYPE_CODE_CHAR || !name)
88 {
89 result = C_CHAR;
90 goto done;
91 }
92
93 if (!strcmp (name, "wchar_t"))
94 {
95 result = C_WIDE_CHAR;
96 goto done;
97 }
98
99 if (!strcmp (name, "char16_t"))
100 {
101 result = C_CHAR_16;
102 goto done;
103 }
104
105 if (!strcmp (name, "char32_t"))
106 {
107 result = C_CHAR_32;
108 goto done;
109 }
110
111 if (TYPE_CODE (elttype) != TYPE_CODE_TYPEDEF)
112 break;
113
114 /* Call for side effects. */
115 check_typedef (elttype);
116
117 if (TYPE_TARGET_TYPE (elttype))
118 elttype = TYPE_TARGET_TYPE (elttype);
119 else
120 {
121 /* Perhaps check_typedef did not update the target type. In
122 this case, force the lookup again and hope it works out.
123 It never will for C, but it might for C++. */
124 elttype = check_typedef (elttype);
125 }
126 }
127
128 /* Punt. */
129 result = C_CHAR;
130
131 done:
132 if (encoding)
133 *encoding = charset_for_string_type (result, gdbarch);
134
135 return result;
136}
137
138/* Print the character C on STREAM as part of the contents of a
139 literal string whose delimiter is QUOTER. Note that that format
140 for printing characters and strings is language specific. */
141
142void
143c_emit_char (int c, struct type *type,
144 struct ui_file *stream, int quoter)
145{
146 const char *encoding;
147
148 classify_type (type, get_type_arch (type), &encoding);
149 generic_emit_char (c, type, stream, quoter, encoding);
150}
151
152void
153c_printchar (int c, struct type *type, struct ui_file *stream)
154{
155 c_string_type str_type;
156
157 str_type = classify_type (type, get_type_arch (type), NULL);
158 switch (str_type)
159 {
160 case C_CHAR:
161 break;
162 case C_WIDE_CHAR:
163 fputc_filtered ('L', stream);
164 break;
165 case C_CHAR_16:
166 fputc_filtered ('u', stream);
167 break;
168 case C_CHAR_32:
169 fputc_filtered ('U', stream);
170 break;
171 }
172
173 fputc_filtered ('\'', stream);
174 LA_EMIT_CHAR (c, type, stream, '\'');
175 fputc_filtered ('\'', stream);
176}
177
178/* Print the character string STRING, printing at most LENGTH
179 characters. LENGTH is -1 if the string is nul terminated. Each
180 character is WIDTH bytes long. Printing stops early if the number
181 hits print_max; repeat counts are printed as appropriate. Print
182 ellipses at the end if we had to stop before printing LENGTH
183 characters, or if FORCE_ELLIPSES. */
184
185void
186c_printstr (struct ui_file *stream, struct type *type,
187 const gdb_byte *string, unsigned int length,
188 const char *user_encoding, int force_ellipses,
189 const struct value_print_options *options)
190{
191 c_string_type str_type;
192 const char *type_encoding;
193 const char *encoding;
194
195 str_type = (classify_type (type, get_type_arch (type), &type_encoding)
196 & ~C_CHAR);
197 switch (str_type)
198 {
199 case C_STRING:
200 break;
201 case C_WIDE_STRING:
202 fputs_filtered ("L", stream);
203 break;
204 case C_STRING_16:
205 fputs_filtered ("u", stream);
206 break;
207 case C_STRING_32:
208 fputs_filtered ("U", stream);
209 break;
210 }
211
212 encoding = (user_encoding && *user_encoding) ? user_encoding : type_encoding;
213
214 generic_printstr (stream, type, string, length, encoding, force_ellipses,
215 '"', 1, options);
216}
217
218/* Obtain a C string from the inferior storing it in a newly allocated
219 buffer in BUFFER, which should be freed by the caller. If the in-
220 and out-parameter *LENGTH is specified at -1, the string is read
221 until a null character of the appropriate width is found, otherwise
222 the string is read to the length of characters specified. The size
223 of a character is determined by the length of the target type of
224 the pointer or array.
225
226 If VALUE is an array with a known length, and *LENGTH is -1,
227 the function will not read past the end of the array. However, any
228 declared size of the array is ignored if *LENGTH > 0.
229
230 On completion, *LENGTH will be set to the size of the string read in
231 characters. (If a length of -1 is specified, the length returned
232 will not include the null character). CHARSET is always set to the
233 target charset. */
234
235void
236c_get_string (struct value *value, gdb_byte **buffer,
237 int *length, struct type **char_type,
238 const char **charset)
239{
240 int err, width;
241 unsigned int fetchlimit;
242 struct type *type = check_typedef (value_type (value));
243 struct type *element_type = TYPE_TARGET_TYPE (type);
244 int req_length = *length;
245 enum bfd_endian byte_order
246 = gdbarch_byte_order (get_type_arch (type));
247
248 if (element_type == NULL)
249 goto error;
250
251 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
252 {
253 /* If we know the size of the array, we can use it as a limit on
254 the number of characters to be fetched. */
255 if (TYPE_NFIELDS (type) == 1
256 && TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_RANGE)
257 {
258 LONGEST low_bound, high_bound;
259
260 get_discrete_bounds (TYPE_FIELD_TYPE (type, 0),
261 &low_bound, &high_bound);
262 fetchlimit = high_bound - low_bound + 1;
263 }
264 else
265 fetchlimit = UINT_MAX;
266 }
267 else if (TYPE_CODE (type) == TYPE_CODE_PTR)
268 fetchlimit = UINT_MAX;
269 else
270 /* We work only with arrays and pointers. */
271 goto error;
272
273 if (! c_textual_element_type (element_type, 0))
274 goto error;
275 classify_type (element_type, get_type_arch (element_type), charset);
276 width = TYPE_LENGTH (element_type);
277
278 /* If the string lives in GDB's memory instead of the inferior's,
279 then we just need to copy it to BUFFER. Also, since such strings
280 are arrays with known size, FETCHLIMIT will hold the size of the
281 array. */
282 if ((VALUE_LVAL (value) == not_lval
283 || VALUE_LVAL (value) == lval_internalvar)
284 && fetchlimit != UINT_MAX)
285 {
286 int i;
287 const gdb_byte *contents = value_contents (value);
288
289 /* If a length is specified, use that. */
290 if (*length >= 0)
291 i = *length;
292 else
293 /* Otherwise, look for a null character. */
294 for (i = 0; i < fetchlimit; i++)
295 if (extract_unsigned_integer (contents + i * width,
296 width, byte_order) == 0)
297 break;
298
299 /* I is now either a user-defined length, the number of non-null
300 characters, or FETCHLIMIT. */
301 *length = i * width;
302 *buffer = (gdb_byte *) xmalloc (*length);
303 memcpy (*buffer, contents, *length);
304 err = 0;
305 }
306 else
307 {
308 CORE_ADDR addr = value_as_address (value);
309
310 /* Prior to the fix for PR 16196 read_string would ignore fetchlimit
311 if length > 0. The old "broken" behaviour is the behaviour we want:
312 The caller may want to fetch 100 bytes from a variable length array
313 implemented using the common idiom of having an array of length 1 at
314 the end of a struct. In this case we want to ignore the declared
315 size of the array. However, it's counterintuitive to implement that
316 behaviour in read_string: what does fetchlimit otherwise mean if
317 length > 0. Therefore we implement the behaviour we want here:
318 If *length > 0, don't specify a fetchlimit. This preserves the
319 previous behaviour. We could move this check above where we know
320 whether the array is declared with a fixed size, but we only want
321 to apply this behaviour when calling read_string. PR 16286. */
322 if (*length > 0)
323 fetchlimit = UINT_MAX;
324
325 err = read_string (addr, *length, width, fetchlimit,
326 byte_order, buffer, length);
327 if (err != 0)
328 {
329 xfree (*buffer);
330 memory_error (TARGET_XFER_E_IO, addr);
331 }
332 }
333
334 /* If the LENGTH is specified at -1, we want to return the string
335 length up to the terminating null character. If an actual length
336 was specified, we want to return the length of exactly what was
337 read. */
338 if (req_length == -1)
339 /* If the last character is null, subtract it from LENGTH. */
340 if (*length > 0
341 && extract_unsigned_integer (*buffer + *length - width,
342 width, byte_order) == 0)
343 *length -= width;
344
345 /* The read_string function will return the number of bytes read.
346 If length returned from read_string was > 0, return the number of
347 characters read by dividing the number of bytes by width. */
348 if (*length != 0)
349 *length = *length / width;
350
351 *char_type = element_type;
352
353 return;
354
355 error:
356 {
357 std::string type_str = type_to_string (type);
358 if (!type_str.empty ())
359 {
360 error (_("Trying to read string with inappropriate type `%s'."),
361 type_str.c_str ());
362 }
363 else
364 error (_("Trying to read string with inappropriate type."));
365 }
366}
367
368\f
369/* Evaluating C and C++ expressions. */
370
371/* Convert a UCN. The digits of the UCN start at P and extend no
372 farther than LIMIT. DEST_CHARSET is the name of the character set
373 into which the UCN should be converted. The results are written to
374 OUTPUT. LENGTH is the maximum length of the UCN, either 4 or 8.
375 Returns a pointer to just after the final digit of the UCN. */
376
377static char *
378convert_ucn (char *p, char *limit, const char *dest_charset,
379 struct obstack *output, int length)
380{
381 unsigned long result = 0;
382 gdb_byte data[4];
383 int i;
384
385 for (i = 0; i < length && p < limit && isxdigit (*p); ++i, ++p)
386 result = (result << 4) + host_hex_value (*p);
387
388 for (i = 3; i >= 0; --i)
389 {
390 data[i] = result & 0xff;
391 result >>= 8;
392 }
393
394 convert_between_encodings ("UTF-32BE", dest_charset, data,
395 4, 4, output, translit_none);
396
397 return p;
398}
399
400/* Emit a character, VALUE, which was specified numerically, to
401 OUTPUT. TYPE is the target character type. */
402
403static void
404emit_numeric_character (struct type *type, unsigned long value,
405 struct obstack *output)
406{
407 gdb_byte *buffer;
408
409 buffer = (gdb_byte *) alloca (TYPE_LENGTH (type));
410 pack_long (buffer, type, value);
411 obstack_grow (output, buffer, TYPE_LENGTH (type));
412}
413
414/* Convert an octal escape sequence. TYPE is the target character
415 type. The digits of the escape sequence begin at P and extend no
416 farther than LIMIT. The result is written to OUTPUT. Returns a
417 pointer to just after the final digit of the escape sequence. */
418
419static char *
420convert_octal (struct type *type, char *p,
421 char *limit, struct obstack *output)
422{
423 int i;
424 unsigned long value = 0;
425
426 for (i = 0;
427 i < 3 && p < limit && isdigit (*p) && *p != '8' && *p != '9';
428 ++i)
429 {
430 value = 8 * value + host_hex_value (*p);
431 ++p;
432 }
433
434 emit_numeric_character (type, value, output);
435
436 return p;
437}
438
439/* Convert a hex escape sequence. TYPE is the target character type.
440 The digits of the escape sequence begin at P and extend no farther
441 than LIMIT. The result is written to OUTPUT. Returns a pointer to
442 just after the final digit of the escape sequence. */
443
444static char *
445convert_hex (struct type *type, char *p,
446 char *limit, struct obstack *output)
447{
448 unsigned long value = 0;
449
450 while (p < limit && isxdigit (*p))
451 {
452 value = 16 * value + host_hex_value (*p);
453 ++p;
454 }
455
456 emit_numeric_character (type, value, output);
457
458 return p;
459}
460
461#define ADVANCE \
462 do { \
463 ++p; \
464 if (p == limit) \
465 error (_("Malformed escape sequence")); \
466 } while (0)
467
468/* Convert an escape sequence to a target format. TYPE is the target
469 character type to use, and DEST_CHARSET is the name of the target
470 character set. The backslash of the escape sequence is at *P, and
471 the escape sequence will not extend past LIMIT. The results are
472 written to OUTPUT. Returns a pointer to just past the final
473 character of the escape sequence. */
474
475static char *
476convert_escape (struct type *type, const char *dest_charset,
477 char *p, char *limit, struct obstack *output)
478{
479 /* Skip the backslash. */
480 ADVANCE;
481
482 switch (*p)
483 {
484 case '\\':
485 obstack_1grow (output, '\\');
486 ++p;
487 break;
488
489 case 'x':
490 ADVANCE;
491 if (!isxdigit (*p))
492 error (_("\\x used with no following hex digits."));
493 p = convert_hex (type, p, limit, output);
494 break;
495
496 case '0':
497 case '1':
498 case '2':
499 case '3':
500 case '4':
501 case '5':
502 case '6':
503 case '7':
504 p = convert_octal (type, p, limit, output);
505 break;
506
507 case 'u':
508 case 'U':
509 {
510 int length = *p == 'u' ? 4 : 8;
511
512 ADVANCE;
513 if (!isxdigit (*p))
514 error (_("\\u used with no following hex digits"));
515 p = convert_ucn (p, limit, dest_charset, output, length);
516 }
517 }
518
519 return p;
520}
521
522/* Given a single string from a (C-specific) OP_STRING list, convert
523 it to a target string, handling escape sequences specially. The
524 output is written to OUTPUT. DATA is the input string, which has
525 length LEN. DEST_CHARSET is the name of the target character set,
526 and TYPE is the type of target character to use. */
527
528static void
529parse_one_string (struct obstack *output, char *data, int len,
530 const char *dest_charset, struct type *type)
531{
532 char *limit;
533
534 limit = data + len;
535
536 while (data < limit)
537 {
538 char *p = data;
539
540 /* Look for next escape, or the end of the input. */
541 while (p < limit && *p != '\\')
542 ++p;
543 /* If we saw a run of characters, convert them all. */
544 if (p > data)
545 convert_between_encodings (host_charset (), dest_charset,
546 (gdb_byte *) data, p - data, 1,
547 output, translit_none);
548 /* If we saw an escape, convert it. */
549 if (p < limit)
550 p = convert_escape (type, dest_charset, p, limit, output);
551 data = p;
552 }
553}
554
555/* Expression evaluator for the C language family. Most operations
556 are delegated to evaluate_subexp_standard; see that function for a
557 description of the arguments. */
558
559struct value *
560evaluate_subexp_c (struct type *expect_type, struct expression *exp,
561 int *pos, enum noside noside)
562{
563 enum exp_opcode op = exp->elts[*pos].opcode;
564
565 switch (op)
566 {
567 case OP_STRING:
568 {
569 int oplen, limit;
570 struct type *type;
571 struct value *result;
572 c_string_type dest_type;
573 const char *dest_charset;
574 int satisfy_expected = 0;
575
576 auto_obstack output;
577
578 ++*pos;
579 oplen = longest_to_int (exp->elts[*pos].longconst);
580
581 ++*pos;
582 limit = *pos + BYTES_TO_EXP_ELEM (oplen + 1);
583 dest_type = ((enum c_string_type_values)
584 longest_to_int (exp->elts[*pos].longconst));
585 switch (dest_type & ~C_CHAR)
586 {
587 case C_STRING:
588 type = language_string_char_type (exp->language_defn,
589 exp->gdbarch);
590 break;
591 case C_WIDE_STRING:
592 type = lookup_typename (exp->language_defn, exp->gdbarch,
593 "wchar_t", NULL, 0);
594 break;
595 case C_STRING_16:
596 type = lookup_typename (exp->language_defn, exp->gdbarch,
597 "char16_t", NULL, 0);
598 break;
599 case C_STRING_32:
600 type = lookup_typename (exp->language_defn, exp->gdbarch,
601 "char32_t", NULL, 0);
602 break;
603 default:
604 internal_error (__FILE__, __LINE__, _("unhandled c_string_type"));
605 }
606
607 /* Ensure TYPE_LENGTH is valid for TYPE. */
608 check_typedef (type);
609
610 /* If the caller expects an array of some integral type,
611 satisfy them. If something odder is expected, rely on the
612 caller to cast. */
613 if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_ARRAY)
614 {
615 struct type *element_type
616 = check_typedef (TYPE_TARGET_TYPE (expect_type));
617
618 if (TYPE_CODE (element_type) == TYPE_CODE_INT
619 || TYPE_CODE (element_type) == TYPE_CODE_CHAR)
620 {
621 type = element_type;
622 satisfy_expected = 1;
623 }
624 }
625
626 dest_charset = charset_for_string_type (dest_type, exp->gdbarch);
627
628 ++*pos;
629 while (*pos < limit)
630 {
631 int len;
632
633 len = longest_to_int (exp->elts[*pos].longconst);
634
635 ++*pos;
636 if (noside != EVAL_SKIP)
637 parse_one_string (&output, &exp->elts[*pos].string, len,
638 dest_charset, type);
639 *pos += BYTES_TO_EXP_ELEM (len);
640 }
641
642 /* Skip the trailing length and opcode. */
643 *pos += 2;
644
645 if (noside == EVAL_SKIP)
646 {
647 /* Return a dummy value of the appropriate type. */
648 if (expect_type != NULL)
649 result = allocate_value (expect_type);
650 else if ((dest_type & C_CHAR) != 0)
651 result = allocate_value (type);
652 else
653 result = value_cstring ("", 0, type);
654 return result;
655 }
656
657 if ((dest_type & C_CHAR) != 0)
658 {
659 LONGEST value;
660
661 if (obstack_object_size (&output) != TYPE_LENGTH (type))
662 error (_("Could not convert character "
663 "constant to target character set"));
664 value = unpack_long (type, (gdb_byte *) obstack_base (&output));
665 result = value_from_longest (type, value);
666 }
667 else
668 {
669 int i;
670
671 /* Write the terminating character. */
672 for (i = 0; i < TYPE_LENGTH (type); ++i)
673 obstack_1grow (&output, 0);
674
675 if (satisfy_expected)
676 {
677 LONGEST low_bound, high_bound;
678 int element_size = TYPE_LENGTH (type);
679
680 if (get_discrete_bounds (TYPE_INDEX_TYPE (expect_type),
681 &low_bound, &high_bound) < 0)
682 {
683 low_bound = 0;
684 high_bound = (TYPE_LENGTH (expect_type) / element_size) - 1;
685 }
686 if (obstack_object_size (&output) / element_size
687 > (high_bound - low_bound + 1))
688 error (_("Too many array elements"));
689
690 result = allocate_value (expect_type);
691 memcpy (value_contents_raw (result), obstack_base (&output),
692 obstack_object_size (&output));
693 }
694 else
695 result = value_cstring ((const char *) obstack_base (&output),
696 obstack_object_size (&output),
697 type);
698 }
699 return result;
700 }
701 break;
702
703 default:
704 break;
705 }
706 return evaluate_subexp_standard (expect_type, exp, pos, noside);
707}
708\f
709/* la_watch_location_expression for C. */
710
711gdb::unique_xmalloc_ptr<char>
712c_watch_location_expression (struct type *type, CORE_ADDR addr)
713{
714 type = check_typedef (TYPE_TARGET_TYPE (check_typedef (type)));
715 std::string name = type_to_string (type);
716 return gdb::unique_xmalloc_ptr<char>
717 (xstrprintf ("* (%s *) %s", name.c_str (), core_addr_to_string (addr)));
718}
719
720\f
721/* Table mapping opcodes into strings for printing operators
722 and precedences of the operators. */
723
724const struct op_print c_op_print_tab[] =
725{
726 {",", BINOP_COMMA, PREC_COMMA, 0},
727 {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
728 {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
729 {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
730 {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
731 {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
732 {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
733 {"==", BINOP_EQUAL, PREC_EQUAL, 0},
734 {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
735 {"<=", BINOP_LEQ, PREC_ORDER, 0},
736 {">=", BINOP_GEQ, PREC_ORDER, 0},
737 {">", BINOP_GTR, PREC_ORDER, 0},
738 {"<", BINOP_LESS, PREC_ORDER, 0},
739 {">>", BINOP_RSH, PREC_SHIFT, 0},
740 {"<<", BINOP_LSH, PREC_SHIFT, 0},
741 {"+", BINOP_ADD, PREC_ADD, 0},
742 {"-", BINOP_SUB, PREC_ADD, 0},
743 {"*", BINOP_MUL, PREC_MUL, 0},
744 {"/", BINOP_DIV, PREC_MUL, 0},
745 {"%", BINOP_REM, PREC_MUL, 0},
746 {"@", BINOP_REPEAT, PREC_REPEAT, 0},
747 {"+", UNOP_PLUS, PREC_PREFIX, 0},
748 {"-", UNOP_NEG, PREC_PREFIX, 0},
749 {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
750 {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
751 {"*", UNOP_IND, PREC_PREFIX, 0},
752 {"&", UNOP_ADDR, PREC_PREFIX, 0},
753 {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
754 {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
755 {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
756 {NULL, OP_NULL, PREC_PREFIX, 0}
757};
758\f
759enum c_primitive_types {
760 c_primitive_type_int,
761 c_primitive_type_long,
762 c_primitive_type_short,
763 c_primitive_type_char,
764 c_primitive_type_float,
765 c_primitive_type_double,
766 c_primitive_type_void,
767 c_primitive_type_long_long,
768 c_primitive_type_signed_char,
769 c_primitive_type_unsigned_char,
770 c_primitive_type_unsigned_short,
771 c_primitive_type_unsigned_int,
772 c_primitive_type_unsigned_long,
773 c_primitive_type_unsigned_long_long,
774 c_primitive_type_long_double,
775 c_primitive_type_complex,
776 c_primitive_type_double_complex,
777 c_primitive_type_decfloat,
778 c_primitive_type_decdouble,
779 c_primitive_type_declong,
780 nr_c_primitive_types
781};
782
783void
784c_language_arch_info (struct gdbarch *gdbarch,
785 struct language_arch_info *lai)
786{
787 const struct builtin_type *builtin = builtin_type (gdbarch);
788
789 lai->string_char_type = builtin->builtin_char;
790 lai->primitive_type_vector
791 = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_c_primitive_types + 1,
792 struct type *);
793 lai->primitive_type_vector [c_primitive_type_int] = builtin->builtin_int;
794 lai->primitive_type_vector [c_primitive_type_long] = builtin->builtin_long;
795 lai->primitive_type_vector [c_primitive_type_short] = builtin->builtin_short;
796 lai->primitive_type_vector [c_primitive_type_char] = builtin->builtin_char;
797 lai->primitive_type_vector [c_primitive_type_float] = builtin->builtin_float;
798 lai->primitive_type_vector [c_primitive_type_double] = builtin->builtin_double;
799 lai->primitive_type_vector [c_primitive_type_void] = builtin->builtin_void;
800 lai->primitive_type_vector [c_primitive_type_long_long] = builtin->builtin_long_long;
801 lai->primitive_type_vector [c_primitive_type_signed_char] = builtin->builtin_signed_char;
802 lai->primitive_type_vector [c_primitive_type_unsigned_char] = builtin->builtin_unsigned_char;
803 lai->primitive_type_vector [c_primitive_type_unsigned_short] = builtin->builtin_unsigned_short;
804 lai->primitive_type_vector [c_primitive_type_unsigned_int] = builtin->builtin_unsigned_int;
805 lai->primitive_type_vector [c_primitive_type_unsigned_long] = builtin->builtin_unsigned_long;
806 lai->primitive_type_vector [c_primitive_type_unsigned_long_long] = builtin->builtin_unsigned_long_long;
807 lai->primitive_type_vector [c_primitive_type_long_double] = builtin->builtin_long_double;
808 lai->primitive_type_vector [c_primitive_type_complex] = builtin->builtin_complex;
809 lai->primitive_type_vector [c_primitive_type_double_complex] = builtin->builtin_double_complex;
810 lai->primitive_type_vector [c_primitive_type_decfloat] = builtin->builtin_decfloat;
811 lai->primitive_type_vector [c_primitive_type_decdouble] = builtin->builtin_decdouble;
812 lai->primitive_type_vector [c_primitive_type_declong] = builtin->builtin_declong;
813
814 lai->bool_type_default = builtin->builtin_int;
815}
816
817const struct exp_descriptor exp_descriptor_c =
818{
819 print_subexp_standard,
820 operator_length_standard,
821 operator_check_standard,
822 op_name_standard,
823 dump_subexp_body_standard,
824 evaluate_subexp_c
825};
826
827static const char *c_extensions[] =
828{
829 ".c", NULL
830};
831
832extern const struct language_defn c_language_defn =
833{
834 "c", /* Language name */
835 "C",
836 language_c,
837 range_check_off,
838 case_sensitive_on,
839 array_row_major,
840 macro_expansion_c,
841 c_extensions,
842 &exp_descriptor_c,
843 c_parse,
844 c_yyerror,
845 null_post_parser,
846 c_printchar, /* Print a character constant */
847 c_printstr, /* Function to print string constant */
848 c_emit_char, /* Print a single char */
849 c_print_type, /* Print a type using appropriate syntax */
850 c_print_typedef, /* Print a typedef using appropriate syntax */
851 c_val_print, /* Print a value using appropriate syntax */
852 c_value_print, /* Print a top-level value */
853 default_read_var_value, /* la_read_var_value */
854 NULL, /* Language specific skip_trampoline */
855 NULL, /* name_of_this */
856 true, /* la_store_sym_names_in_linkage_form_p */
857 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
858 basic_lookup_transparent_type,/* lookup_transparent_type */
859 NULL, /* Language specific symbol demangler */
860 NULL,
861 NULL, /* Language specific
862 class_name_from_physname */
863 c_op_print_tab, /* expression operators for printing */
864 1, /* c-style arrays */
865 0, /* String lower bound */
866 default_word_break_characters,
867 default_collect_symbol_completion_matches,
868 c_language_arch_info,
869 default_print_array_index,
870 default_pass_by_reference,
871 c_get_string,
872 c_watch_location_expression,
873 NULL, /* la_get_symbol_name_matcher */
874 iterate_over_symbols,
875 default_search_name_hash,
876 &c_varobj_ops,
877 c_get_compile_context,
878 c_compute_program,
879 LANG_MAGIC
880};
881
882enum cplus_primitive_types {
883 cplus_primitive_type_int,
884 cplus_primitive_type_long,
885 cplus_primitive_type_short,
886 cplus_primitive_type_char,
887 cplus_primitive_type_float,
888 cplus_primitive_type_double,
889 cplus_primitive_type_void,
890 cplus_primitive_type_long_long,
891 cplus_primitive_type_signed_char,
892 cplus_primitive_type_unsigned_char,
893 cplus_primitive_type_unsigned_short,
894 cplus_primitive_type_unsigned_int,
895 cplus_primitive_type_unsigned_long,
896 cplus_primitive_type_unsigned_long_long,
897 cplus_primitive_type_long_double,
898 cplus_primitive_type_complex,
899 cplus_primitive_type_double_complex,
900 cplus_primitive_type_bool,
901 cplus_primitive_type_decfloat,
902 cplus_primitive_type_decdouble,
903 cplus_primitive_type_declong,
904 cplus_primitive_type_char16_t,
905 cplus_primitive_type_char32_t,
906 cplus_primitive_type_wchar_t,
907 nr_cplus_primitive_types
908};
909
910static void
911cplus_language_arch_info (struct gdbarch *gdbarch,
912 struct language_arch_info *lai)
913{
914 const struct builtin_type *builtin = builtin_type (gdbarch);
915
916 lai->string_char_type = builtin->builtin_char;
917 lai->primitive_type_vector
918 = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_cplus_primitive_types + 1,
919 struct type *);
920 lai->primitive_type_vector [cplus_primitive_type_int]
921 = builtin->builtin_int;
922 lai->primitive_type_vector [cplus_primitive_type_long]
923 = builtin->builtin_long;
924 lai->primitive_type_vector [cplus_primitive_type_short]
925 = builtin->builtin_short;
926 lai->primitive_type_vector [cplus_primitive_type_char]
927 = builtin->builtin_char;
928 lai->primitive_type_vector [cplus_primitive_type_float]
929 = builtin->builtin_float;
930 lai->primitive_type_vector [cplus_primitive_type_double]
931 = builtin->builtin_double;
932 lai->primitive_type_vector [cplus_primitive_type_void]
933 = builtin->builtin_void;
934 lai->primitive_type_vector [cplus_primitive_type_long_long]
935 = builtin->builtin_long_long;
936 lai->primitive_type_vector [cplus_primitive_type_signed_char]
937 = builtin->builtin_signed_char;
938 lai->primitive_type_vector [cplus_primitive_type_unsigned_char]
939 = builtin->builtin_unsigned_char;
940 lai->primitive_type_vector [cplus_primitive_type_unsigned_short]
941 = builtin->builtin_unsigned_short;
942 lai->primitive_type_vector [cplus_primitive_type_unsigned_int]
943 = builtin->builtin_unsigned_int;
944 lai->primitive_type_vector [cplus_primitive_type_unsigned_long]
945 = builtin->builtin_unsigned_long;
946 lai->primitive_type_vector [cplus_primitive_type_unsigned_long_long]
947 = builtin->builtin_unsigned_long_long;
948 lai->primitive_type_vector [cplus_primitive_type_long_double]
949 = builtin->builtin_long_double;
950 lai->primitive_type_vector [cplus_primitive_type_complex]
951 = builtin->builtin_complex;
952 lai->primitive_type_vector [cplus_primitive_type_double_complex]
953 = builtin->builtin_double_complex;
954 lai->primitive_type_vector [cplus_primitive_type_bool]
955 = builtin->builtin_bool;
956 lai->primitive_type_vector [cplus_primitive_type_decfloat]
957 = builtin->builtin_decfloat;
958 lai->primitive_type_vector [cplus_primitive_type_decdouble]
959 = builtin->builtin_decdouble;
960 lai->primitive_type_vector [cplus_primitive_type_declong]
961 = builtin->builtin_declong;
962 lai->primitive_type_vector [cplus_primitive_type_char16_t]
963 = builtin->builtin_char16;
964 lai->primitive_type_vector [cplus_primitive_type_char32_t]
965 = builtin->builtin_char32;
966 lai->primitive_type_vector [cplus_primitive_type_wchar_t]
967 = builtin->builtin_wchar;
968
969 lai->bool_type_symbol = "bool";
970 lai->bool_type_default = builtin->builtin_bool;
971}
972
973static const char *cplus_extensions[] =
974{
975 ".C", ".cc", ".cp", ".cpp", ".cxx", ".c++", NULL
976};
977
978extern const struct language_defn cplus_language_defn =
979{
980 "c++", /* Language name */
981 "C++",
982 language_cplus,
983 range_check_off,
984 case_sensitive_on,
985 array_row_major,
986 macro_expansion_c,
987 cplus_extensions,
988 &exp_descriptor_c,
989 c_parse,
990 c_yyerror,
991 null_post_parser,
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,
1017 c_get_string,
1018 c_watch_location_expression,
1019 cp_get_symbol_name_matcher,
1020 iterate_over_symbols,
1021 cp_search_name_hash,
1022 &cplus_varobj_ops,
1023 NULL,
1024 NULL,
1025 LANG_MAGIC
1026};
1027
1028static const char *asm_extensions[] =
1029{
1030 ".s", ".sx", ".S", NULL
1031};
1032
1033extern const struct language_defn asm_language_defn =
1034{
1035 "asm", /* Language name */
1036 "assembly",
1037 language_asm,
1038 range_check_off,
1039 case_sensitive_on,
1040 array_row_major,
1041 macro_expansion_c,
1042 asm_extensions,
1043 &exp_descriptor_c,
1044 c_parse,
1045 c_yyerror,
1046 null_post_parser,
1047 c_printchar, /* Print a character constant */
1048 c_printstr, /* Function to print string constant */
1049 c_emit_char, /* Print a single char */
1050 c_print_type, /* Print a type using appropriate syntax */
1051 c_print_typedef, /* Print a typedef using appropriate syntax */
1052 c_val_print, /* Print a value using appropriate syntax */
1053 c_value_print, /* Print a top-level value */
1054 default_read_var_value, /* la_read_var_value */
1055 NULL, /* Language specific skip_trampoline */
1056 NULL, /* name_of_this */
1057 true, /* la_store_sym_names_in_linkage_form_p */
1058 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1059 basic_lookup_transparent_type,/* lookup_transparent_type */
1060 NULL, /* Language specific symbol demangler */
1061 NULL,
1062 NULL, /* Language specific
1063 class_name_from_physname */
1064 c_op_print_tab, /* expression operators for printing */
1065 1, /* c-style arrays */
1066 0, /* String lower bound */
1067 default_word_break_characters,
1068 default_collect_symbol_completion_matches,
1069 c_language_arch_info, /* FIXME: la_language_arch_info. */
1070 default_print_array_index,
1071 default_pass_by_reference,
1072 c_get_string,
1073 c_watch_location_expression,
1074 NULL, /* la_get_symbol_name_matcher */
1075 iterate_over_symbols,
1076 default_search_name_hash,
1077 &default_varobj_ops,
1078 NULL,
1079 NULL,
1080 LANG_MAGIC
1081};
1082
1083/* The following language_defn does not represent a real language.
1084 It just provides a minimal support a-la-C that should allow users
1085 to do some simple operations when debugging applications that use
1086 a language currently not supported by GDB. */
1087
1088extern const struct language_defn minimal_language_defn =
1089{
1090 "minimal", /* Language name */
1091 "Minimal",
1092 language_minimal,
1093 range_check_off,
1094 case_sensitive_on,
1095 array_row_major,
1096 macro_expansion_c,
1097 NULL,
1098 &exp_descriptor_c,
1099 c_parse,
1100 c_yyerror,
1101 null_post_parser,
1102 c_printchar, /* Print a character constant */
1103 c_printstr, /* Function to print string constant */
1104 c_emit_char, /* Print a single char */
1105 c_print_type, /* Print a type using appropriate syntax */
1106 c_print_typedef, /* Print a typedef using appropriate syntax */
1107 c_val_print, /* Print a value using appropriate syntax */
1108 c_value_print, /* Print a top-level value */
1109 default_read_var_value, /* la_read_var_value */
1110 NULL, /* Language specific skip_trampoline */
1111 NULL, /* name_of_this */
1112 true, /* la_store_sym_names_in_linkage_form_p */
1113 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1114 basic_lookup_transparent_type,/* lookup_transparent_type */
1115 NULL, /* Language specific symbol demangler */
1116 NULL,
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_collect_symbol_completion_matches,
1124 c_language_arch_info,
1125 default_print_array_index,
1126 default_pass_by_reference,
1127 c_get_string,
1128 c_watch_location_expression,
1129 NULL, /* la_get_symbol_name_matcher */
1130 iterate_over_symbols,
1131 default_search_name_hash,
1132 &default_varobj_ops,
1133 NULL,
1134 NULL,
1135 LANG_MAGIC
1136};
GDB Binutils - Deliverables
This page took 0.026762 seconds and 4 git commands to generate.