?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Remove old autovect-branch by moving to "dead" directory.
[official-gcc.git] / old-autovect-branch / gcc / cp / error.c
blobbe0ee5968eedc673fa8bc8c8b0ee0f866d7fe102
1 /* Call-backs for C++ error reporting.
2 This code is non-reentrant.
3 Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2002,
4 2003, 2004, 2005 Free Software Foundation, Inc.
5 This file is part of GCC.
6
7 GCC 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 2, or (at your option)
10 any later version.
11
12 GCC 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 GCC; see the file COPYING. If not, write to
19 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
21
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "tm.h"
26 #include "tree.h"
27 #include "cp-tree.h"
28 #include "real.h"
29 #include "toplev.h"
30 #include "flags.h"
31 #include "diagnostic.h"
32 #include "langhooks-def.h"
33 #include "cxx-pretty-print.h"
34
35 #define pp_separate_with_comma(PP) pp_cxx_separate_with (PP, ',')
36
37 /* The global buffer where we dump everything. It is there only for
38 transitional purpose. It is expected, in the near future, to be
39 completely removed. */
40 static cxx_pretty_printer scratch_pretty_printer;
41 #define cxx_pp (&scratch_pretty_printer)
42
43 # define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T)))
44
45 static const char *args_to_string (tree, int);
46 static const char *assop_to_string (enum tree_code);
47 static const char *code_to_string (enum tree_code);
48 static const char *cv_to_string (tree, int);
49 static const char *decl_to_string (tree, int);
50 static const char *expr_to_string (tree);
51 static const char *fndecl_to_string (tree, int);
52 static const char *op_to_string (enum tree_code);
53 static const char *parm_to_string (int);
54 static const char *type_to_string (tree, int);
55
56 static void dump_type (tree, int);
57 static void dump_typename (tree, int);
58 static void dump_simple_decl (tree, tree, int);
59 static void dump_decl (tree, int);
60 static void dump_template_decl (tree, int);
61 static void dump_function_decl (tree, int);
62 static void dump_expr (tree, int);
63 static void dump_unary_op (const char *, tree, int);
64 static void dump_binary_op (const char *, tree, int);
65 static void dump_aggr_type (tree, int);
66 static void dump_type_prefix (tree, int);
67 static void dump_type_suffix (tree, int);
68 static void dump_function_name (tree, int);
69 static void dump_expr_list (tree, int);
70 static void dump_global_iord (tree);
71 static void dump_parameters (tree, int);
72 static void dump_exception_spec (tree, int);
73 static void dump_template_argument (tree, int);
74 static void dump_template_argument_list (tree, int);
75 static void dump_template_parameter (tree, int);
76 static void dump_template_bindings (tree, tree);
77 static void dump_scope (tree, int);
78 static void dump_template_parms (tree, int, int);
79
80 static const char *function_category (tree);
81 static void maybe_print_instantiation_context (diagnostic_context *);
82 static void print_instantiation_full_context (diagnostic_context *);
83 static void print_instantiation_partial_context (diagnostic_context *,
84 tree, location_t);
85 static void cp_diagnostic_starter (diagnostic_context *, diagnostic_info *);
86 static void cp_diagnostic_finalizer (diagnostic_context *, diagnostic_info *);
87 static void cp_print_error_function (diagnostic_context *, diagnostic_info *);
88
89 static bool cp_printer (pretty_printer *, text_info *, const char *,
90 int, bool, bool, bool);
91 static location_t location_of (tree);
92
93 void
94 init_error (void)
95 {
96 diagnostic_starter (global_dc) = cp_diagnostic_starter;
97 diagnostic_finalizer (global_dc) = cp_diagnostic_finalizer;
98 diagnostic_format_decoder (global_dc) = cp_printer;
99
100 pp_construct (pp_base (cxx_pp), NULL, 0);
101 pp_cxx_pretty_printer_init (cxx_pp);
102 }
103
104 /* Dump a scope, if deemed necessary. */
105
106 static void
107 dump_scope (tree scope, int flags)
108 {
109 int f = ~TFF_RETURN_TYPE & (flags & (TFF_SCOPE | TFF_CHASE_TYPEDEF));
110
111 if (scope == NULL_TREE)
112 return;
113
114 if (TREE_CODE (scope) == NAMESPACE_DECL)
115 {
116 if (scope != global_namespace)
117 {
118 dump_decl (scope, f);
119 pp_cxx_colon_colon (cxx_pp);
120 }
121 }
122 else if (AGGREGATE_TYPE_P (scope))
123 {
124 dump_type (scope, f);
125 pp_cxx_colon_colon (cxx_pp);
126 }
127 else if ((flags & TFF_SCOPE) && TREE_CODE (scope) == FUNCTION_DECL)
128 {
129 dump_function_decl (scope, f);
130 pp_cxx_colon_colon (cxx_pp);
131 }
132 }
133
134 /* Dump the template ARGument under control of FLAGS. */
135
136 static void
137 dump_template_argument (tree arg, int flags)
138 {
139 if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
140 dump_type (arg, flags & ~TFF_CLASS_KEY_OR_ENUM);
141 else
142 dump_expr (arg, (flags | TFF_EXPR_IN_PARENS) & ~TFF_CLASS_KEY_OR_ENUM);
143 }
144
145 /* Dump a template-argument-list ARGS (always a TREE_VEC) under control
146 of FLAGS. */
147
148 static void
149 dump_template_argument_list (tree args, int flags)
150 {
151 int n = TREE_VEC_LENGTH (args);
152 int need_comma = 0;
153 int i;
154
155 for (i = 0; i< n; ++i)
156 {
157 if (need_comma)
158 pp_separate_with_comma (cxx_pp);
159 dump_template_argument (TREE_VEC_ELT (args, i), flags);
160 need_comma = 1;
161 }
162 }
163
164 /* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */
165
166 static void
167 dump_template_parameter (tree parm, int flags)
168 {
169 tree p = TREE_VALUE (parm);
170 tree a = TREE_PURPOSE (parm);
171
172 if (TREE_CODE (p) == TYPE_DECL)
173 {
174 if (flags & TFF_DECL_SPECIFIERS)
175 {
176 pp_cxx_identifier (cxx_pp, "class");
177 if (DECL_NAME (p))
178 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
179 }
180 else if (DECL_NAME (p))
181 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
182 else
183 pp_cxx_canonical_template_parameter (cxx_pp, TREE_TYPE (p));
184 }
185 else
186 dump_decl (p, flags | TFF_DECL_SPECIFIERS);
187
188 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && a != NULL_TREE)
189 {
190 pp_cxx_whitespace (cxx_pp);
191 pp_equal (cxx_pp);
192 pp_cxx_whitespace (cxx_pp);
193 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
194 dump_type (a, flags & ~TFF_CHASE_TYPEDEF);
195 else
196 dump_expr (a, flags | TFF_EXPR_IN_PARENS);
197 }
198 }
199
200 /* Dump, under control of FLAGS, a template-parameter-list binding.
201 PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a
202 TREE_VEC. */
203
204 static void
205 dump_template_bindings (tree parms, tree args)
206 {
207 int need_comma = 0;
208
209 while (parms)
210 {
211 tree p = TREE_VALUE (parms);
212 int lvl = TMPL_PARMS_DEPTH (parms);
213 int arg_idx = 0;
214 int i;
215
216 for (i = 0; i < TREE_VEC_LENGTH (p); ++i)
217 {
218 tree arg = NULL_TREE;
219
220 /* Don't crash if we had an invalid argument list. */
221 if (TMPL_ARGS_DEPTH (args) >= lvl)
222 {
223 tree lvl_args = TMPL_ARGS_LEVEL (args, lvl);
224 if (NUM_TMPL_ARGS (lvl_args) > arg_idx)
225 arg = TREE_VEC_ELT (lvl_args, arg_idx);
226 }
227
228 if (need_comma)
229 pp_separate_with_comma (cxx_pp);
230 dump_template_parameter (TREE_VEC_ELT (p, i), TFF_PLAIN_IDENTIFIER);
231 pp_cxx_whitespace (cxx_pp);
232 pp_equal (cxx_pp);
233 pp_cxx_whitespace (cxx_pp);
234 if (arg)
235 dump_template_argument (arg, TFF_PLAIN_IDENTIFIER);
236 else
237 pp_identifier (cxx_pp, "<missing>");
238
239 ++arg_idx;
240 need_comma = 1;
241 }
242
243 parms = TREE_CHAIN (parms);
244 }
245 }
246
247 /* Dump a human-readable equivalent of TYPE. FLAGS controls the
248 format. */
249
250 static void
251 dump_type (tree t, int flags)
252 {
253 if (t == NULL_TREE)
254 return;
255
256 if (TYPE_PTRMEMFUNC_P (t))
257 goto offset_type;
258
259 switch (TREE_CODE (t))
260 {
261 case UNKNOWN_TYPE:
262 pp_identifier (cxx_pp, "<unresolved overloaded function type>");
263 break;
264
265 case TREE_LIST:
266 /* A list of function parms. */
267 dump_parameters (t, flags);
268 break;
269
270 case IDENTIFIER_NODE:
271 pp_cxx_tree_identifier (cxx_pp, t);
272 break;
273
274 case TREE_BINFO:
275 dump_type (BINFO_TYPE (t), flags);
276 break;
277
278 case RECORD_TYPE:
279 case UNION_TYPE:
280 case ENUMERAL_TYPE:
281 dump_aggr_type (t, flags);
282 break;
283
284 case TYPE_DECL:
285 if (flags & TFF_CHASE_TYPEDEF)
286 {
287 dump_type (DECL_ORIGINAL_TYPE (t)
288 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags);
289 break;
290 }
291 /* Else fall through. */
292
293 case TEMPLATE_DECL:
294 case NAMESPACE_DECL:
295 dump_decl (t, flags & ~TFF_DECL_SPECIFIERS);
296 break;
297
298 case INTEGER_TYPE:
299 case REAL_TYPE:
300 case VOID_TYPE:
301 case BOOLEAN_TYPE:
302 case COMPLEX_TYPE:
303 case VECTOR_TYPE:
304 pp_type_specifier_seq (cxx_pp, t);
305 break;
306
307 case TEMPLATE_TEMPLATE_PARM:
308 /* For parameters inside template signature. */
309 if (TYPE_IDENTIFIER (t))
310 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
311 else
312 pp_cxx_canonical_template_parameter (cxx_pp, t);
313 break;
314
315 case BOUND_TEMPLATE_TEMPLATE_PARM:
316 {
317 tree args = TYPE_TI_ARGS (t);
318 pp_cxx_cv_qualifier_seq (cxx_pp, t);
319 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
320 pp_cxx_begin_template_argument_list (cxx_pp);
321 dump_template_argument_list (args, flags);
322 pp_cxx_end_template_argument_list (cxx_pp);
323 }
324 break;
325
326 case TEMPLATE_TYPE_PARM:
327 pp_cxx_cv_qualifier_seq (cxx_pp, t);
328 if (TYPE_IDENTIFIER (t))
329 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
330 else
331 pp_cxx_canonical_template_parameter
332 (cxx_pp, TEMPLATE_TYPE_PARM_INDEX (t));
333 break;
334
335 /* This is not always necessary for pointers and such, but doing this
336 reduces code size. */
337 case ARRAY_TYPE:
338 case POINTER_TYPE:
339 case REFERENCE_TYPE:
340 case OFFSET_TYPE:
341 offset_type:
342 case FUNCTION_TYPE:
343 case METHOD_TYPE:
344 {
345 dump_type_prefix (t, flags);
346 dump_type_suffix (t, flags);
347 break;
348 }
349 case TYPENAME_TYPE:
350 pp_cxx_cv_qualifier_seq (cxx_pp, t);
351 pp_cxx_identifier (cxx_pp,
352 TYPENAME_IS_ENUM_P (t) ? "enum"
353 : TYPENAME_IS_CLASS_P (t) ? "class"
354 : "typename");
355 dump_typename (t, flags);
356 break;
357
358 case UNBOUND_CLASS_TEMPLATE:
359 dump_type (TYPE_CONTEXT (t), flags);
360 pp_cxx_colon_colon (cxx_pp);
361 pp_cxx_identifier (cxx_pp, "template");
362 dump_type (DECL_NAME (TYPE_NAME (t)), flags);
363 break;
364
365 case TYPEOF_TYPE:
366 pp_cxx_identifier (cxx_pp, "__typeof__");
367 pp_cxx_whitespace (cxx_pp);
368 pp_cxx_left_paren (cxx_pp);
369 dump_expr (TYPEOF_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
370 pp_cxx_right_paren (cxx_pp);
371 break;
372
373 default:
374 pp_unsupported_tree (cxx_pp, t);
375 /* Fall through to error. */
376
377 case ERROR_MARK:
378 pp_identifier (cxx_pp, "<type error>");
379 break;
380 }
381 }
382
383 /* Dump a TYPENAME_TYPE. We need to notice when the context is itself
384 a TYPENAME_TYPE. */
385
386 static void
387 dump_typename (tree t, int flags)
388 {
389 tree ctx = TYPE_CONTEXT (t);
390
391 if (TREE_CODE (ctx) == TYPENAME_TYPE)
392 dump_typename (ctx, flags);
393 else
394 dump_type (ctx, flags & ~TFF_CLASS_KEY_OR_ENUM);
395 pp_cxx_colon_colon (cxx_pp);
396 dump_decl (TYPENAME_TYPE_FULLNAME (t), flags);
397 }
398
399 /* Return the name of the supplied aggregate, or enumeral type. */
400
401 const char *
402 class_key_or_enum_as_string (tree t)
403 {
404 if (TREE_CODE (t) == ENUMERAL_TYPE)
405 return "enum";
406 else if (TREE_CODE (t) == UNION_TYPE)
407 return "union";
408 else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t))
409 return "class";
410 else
411 return "struct";
412 }
413
414 /* Print out a class declaration T under the control of FLAGS,
415 in the form `class foo'. */
416
417 static void
418 dump_aggr_type (tree t, int flags)
419 {
420 tree name;
421 const char *variety = class_key_or_enum_as_string (t);
422 int typdef = 0;
423 int tmplate = 0;
424
425 pp_cxx_cv_qualifier_seq (cxx_pp, t);
426
427 if (flags & TFF_CLASS_KEY_OR_ENUM)
428 pp_cxx_identifier (cxx_pp, variety);
429
430 if (flags & TFF_CHASE_TYPEDEF)
431 t = TYPE_MAIN_VARIANT (t);
432
433 name = TYPE_NAME (t);
434
435 if (name)
436 {
437 typdef = !DECL_ARTIFICIAL (name);
438 tmplate = !typdef && TREE_CODE (t) != ENUMERAL_TYPE
439 && TYPE_LANG_SPECIFIC (t) && CLASSTYPE_TEMPLATE_INFO (t)
440 && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL
441 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)));
442 dump_scope (CP_DECL_CONTEXT (name), flags | TFF_SCOPE);
443 if (tmplate)
444 {
445 /* Because the template names are mangled, we have to locate
446 the most general template, and use that name. */
447 tree tpl = CLASSTYPE_TI_TEMPLATE (t);
448
449 while (DECL_TEMPLATE_INFO (tpl))
450 tpl = DECL_TI_TEMPLATE (tpl);
451 name = tpl;
452 }
453 name = DECL_NAME (name);
454 }
455
456 if (name == 0 || ANON_AGGRNAME_P (name))
457 {
458 if (flags & TFF_CLASS_KEY_OR_ENUM)
459 pp_identifier (cxx_pp, "<anonymous>");
460 else
461 pp_printf (pp_base (cxx_pp), "<anonymous %s>", variety);
462 }
463 else
464 pp_cxx_tree_identifier (cxx_pp, name);
465 if (tmplate)
466 dump_template_parms (TYPE_TEMPLATE_INFO (t),
467 !CLASSTYPE_USE_TEMPLATE (t),
468 flags & ~TFF_TEMPLATE_HEADER);
469 }
470
471 /* Dump into the obstack the initial part of the output for a given type.
472 This is necessary when dealing with things like functions returning
473 functions. Examples:
474
475 return type of `int (* fee ())()': pointer -> function -> int. Both
476 pointer (and reference and offset) and function (and member) types must
477 deal with prefix and suffix.
478
479 Arrays must also do this for DECL nodes, like int a[], and for things like
480 int *[]&. */
481
482 static void
483 dump_type_prefix (tree t, int flags)
484 {
485 if (TYPE_PTRMEMFUNC_P (t))
486 {
487 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
488 goto offset_type;
489 }
490
491 switch (TREE_CODE (t))
492 {
493 case POINTER_TYPE:
494 case REFERENCE_TYPE:
495 {
496 tree sub = TREE_TYPE (t);
497
498 dump_type_prefix (sub, flags);
499 if (TREE_CODE (sub) == ARRAY_TYPE)
500 {
501 pp_cxx_whitespace (cxx_pp);
502 pp_cxx_left_paren (cxx_pp);
503 }
504 pp_character (cxx_pp, "&*"[TREE_CODE (t) == POINTER_TYPE]);
505 pp_base (cxx_pp)->padding = pp_before;
506 pp_cxx_cv_qualifier_seq (cxx_pp, t);
507 }
508 break;
509
510 case OFFSET_TYPE:
511 offset_type:
512 dump_type_prefix (TREE_TYPE (t), flags);
513 if (TREE_CODE (t) == OFFSET_TYPE) /* pmfs deal with this in d_t_p */
514 {
515 pp_maybe_space (cxx_pp);
516 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
517 pp_cxx_left_paren (cxx_pp);
518 dump_type (TYPE_OFFSET_BASETYPE (t), flags);
519 pp_cxx_colon_colon (cxx_pp);
520 }
521 pp_cxx_star (cxx_pp);
522 pp_cxx_cv_qualifier_seq (cxx_pp, t);
523 pp_base (cxx_pp)->padding = pp_before;
524 break;
525
526 /* Can only be reached through function pointer -- this would not be
527 correct if FUNCTION_DECLs used it. */
528 case FUNCTION_TYPE:
529 dump_type_prefix (TREE_TYPE (t), flags);
530 pp_maybe_space (cxx_pp);
531 pp_cxx_left_paren (cxx_pp);
532 break;
533
534 case METHOD_TYPE:
535 dump_type_prefix (TREE_TYPE (t), flags);
536 pp_maybe_space (cxx_pp);
537 pp_cxx_left_paren (cxx_pp);
538 dump_aggr_type (TYPE_METHOD_BASETYPE (t), flags);
539 pp_cxx_colon_colon (cxx_pp);
540 break;
541
542 case ARRAY_TYPE:
543 dump_type_prefix (TREE_TYPE (t), flags);
544 break;
545
546 case ENUMERAL_TYPE:
547 case IDENTIFIER_NODE:
548 case INTEGER_TYPE:
549 case BOOLEAN_TYPE:
550 case REAL_TYPE:
551 case RECORD_TYPE:
552 case TEMPLATE_TYPE_PARM:
553 case TEMPLATE_TEMPLATE_PARM:
554 case BOUND_TEMPLATE_TEMPLATE_PARM:
555 case TREE_LIST:
556 case TYPE_DECL:
557 case TREE_VEC:
558 case UNION_TYPE:
559 case UNKNOWN_TYPE:
560 case VOID_TYPE:
561 case TYPENAME_TYPE:
562 case COMPLEX_TYPE:
563 case VECTOR_TYPE:
564 case TYPEOF_TYPE:
565 dump_type (t, flags);
566 pp_base (cxx_pp)->padding = pp_before;
567 break;
568
569 default:
570 pp_unsupported_tree (cxx_pp, t);
571 /* fall through. */
572 case ERROR_MARK:
573 pp_identifier (cxx_pp, "<typeprefixerror>");
574 break;
575 }
576 }
577
578 /* Dump the suffix of type T, under control of FLAGS. This is the part
579 which appears after the identifier (or function parms). */
580
581 static void
582 dump_type_suffix (tree t, int flags)
583 {
584 if (TYPE_PTRMEMFUNC_P (t))
585 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
586
587 switch (TREE_CODE (t))
588 {
589 case POINTER_TYPE:
590 case REFERENCE_TYPE:
591 case OFFSET_TYPE:
592 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
593 pp_cxx_right_paren (cxx_pp);
594 dump_type_suffix (TREE_TYPE (t), flags);
595 break;
596
597 /* Can only be reached through function pointer. */
598 case FUNCTION_TYPE:
599 case METHOD_TYPE:
600 {
601 tree arg;
602 pp_cxx_right_paren (cxx_pp);
603 arg = TYPE_ARG_TYPES (t);
604 if (TREE_CODE (t) == METHOD_TYPE)
605 arg = TREE_CHAIN (arg);
606
607 /* Function pointers don't have default args. Not in standard C++,
608 anyway; they may in g++, but we'll just pretend otherwise. */
609 dump_parameters (arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS);
610
611 if (TREE_CODE (t) == METHOD_TYPE)
612 pp_cxx_cv_qualifier_seq
613 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))));
614 else
615 pp_cxx_cv_qualifier_seq(cxx_pp, t);
616 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t), flags);
617 dump_type_suffix (TREE_TYPE (t), flags);
618 break;
619 }
620
621 case ARRAY_TYPE:
622 pp_maybe_space (cxx_pp);
623 pp_cxx_left_bracket (cxx_pp);
624 if (TYPE_DOMAIN (t))
625 {
626 if (host_integerp (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0))
627 pp_wide_integer
628 (cxx_pp, tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0) + 1);
629 else if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (t))) == MINUS_EXPR)
630 dump_expr (TREE_OPERAND (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0),
631 flags & ~TFF_EXPR_IN_PARENS);
632 else
633 dump_expr (fold (cp_build_binary_op
634 (PLUS_EXPR, TYPE_MAX_VALUE (TYPE_DOMAIN (t)),
635 integer_one_node)),
636 flags & ~TFF_EXPR_IN_PARENS);
637 }
638 pp_cxx_right_bracket (cxx_pp);
639 dump_type_suffix (TREE_TYPE (t), flags);
640 break;
641
642 case ENUMERAL_TYPE:
643 case IDENTIFIER_NODE:
644 case INTEGER_TYPE:
645 case BOOLEAN_TYPE:
646 case REAL_TYPE:
647 case RECORD_TYPE:
648 case TEMPLATE_TYPE_PARM:
649 case TEMPLATE_TEMPLATE_PARM:
650 case BOUND_TEMPLATE_TEMPLATE_PARM:
651 case TREE_LIST:
652 case TYPE_DECL:
653 case TREE_VEC:
654 case UNION_TYPE:
655 case UNKNOWN_TYPE:
656 case VOID_TYPE:
657 case TYPENAME_TYPE:
658 case COMPLEX_TYPE:
659 case VECTOR_TYPE:
660 case TYPEOF_TYPE:
661 break;
662
663 default:
664 pp_unsupported_tree (cxx_pp, t);
665 case ERROR_MARK:
666 /* Don't mark it here, we should have already done in
667 dump_type_prefix. */
668 break;
669 }
670 }
671
672 static void
673 dump_global_iord (tree t)
674 {
675 const char *p = NULL;
676
677 if (DECL_GLOBAL_CTOR_P (t))
678 p = "initializers";
679 else if (DECL_GLOBAL_DTOR_P (t))
680 p = "destructors";
681 else
682 gcc_unreachable ();
683
684 pp_printf (pp_base (cxx_pp), "(static %s for %s)", p, input_filename);
685 }
686
687 static void
688 dump_simple_decl (tree t, tree type, int flags)
689 {
690 if (flags & TFF_DECL_SPECIFIERS)
691 {
692 dump_type_prefix (type, flags);
693 pp_maybe_space (cxx_pp);
694 }
695 if (!DECL_INITIAL (t) || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX)
696 dump_scope (CP_DECL_CONTEXT (t), flags);
697 if (DECL_NAME (t))
698 dump_decl (DECL_NAME (t), flags);
699 else
700 pp_identifier (cxx_pp, "<anonymous>");
701 if (flags & TFF_DECL_SPECIFIERS)
702 dump_type_suffix (type, flags);
703 }
704
705 /* Dump a human readable string for the decl T under control of FLAGS. */
706
707 static void
708 dump_decl (tree t, int flags)
709 {
710 if (t == NULL_TREE)
711 return;
712
713 switch (TREE_CODE (t))
714 {
715 case TYPE_DECL:
716 /* Don't say 'typedef class A' */
717 if (DECL_ARTIFICIAL (t))
718 {
719 if ((flags & TFF_DECL_SPECIFIERS)
720 && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
721 /* Say `class T' not just `T'. */
722 pp_cxx_identifier (cxx_pp, "class");
723
724 dump_type (TREE_TYPE (t), flags);
725 break;
726 }
727 if (flags & TFF_DECL_SPECIFIERS)
728 pp_cxx_identifier (cxx_pp, "typedef");
729 dump_simple_decl (t, DECL_ORIGINAL_TYPE (t)
730 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t),
731 flags);
732 break;
733
734 case VAR_DECL:
735 if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t)))
736 {
737 pp_string (cxx_pp, "vtable for ");
738 gcc_assert (TYPE_P (DECL_CONTEXT (t)));
739 dump_type (DECL_CONTEXT (t), flags);
740 break;
741 }
742 /* Else fall through. */
743 case FIELD_DECL:
744 case PARM_DECL:
745 dump_simple_decl (t, TREE_TYPE (t), flags);
746 break;
747
748 case RESULT_DECL:
749 pp_string (cxx_pp, "<return value> ");
750 dump_simple_decl (t, TREE_TYPE (t), flags);
751 break;
752
753 case NAMESPACE_DECL:
754 if (flags & TFF_DECL_SPECIFIERS)
755 pp_cxx_declaration (cxx_pp, t);
756 else
757 {
758 dump_scope (CP_DECL_CONTEXT (t), flags);
759 if (DECL_NAME (t) == NULL_TREE)
760 pp_identifier (cxx_pp, "<unnamed>");
761 else
762 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
763 }
764 break;
765
766 case SCOPE_REF:
767 pp_expression (cxx_pp, t);
768 break;
769
770 case ARRAY_REF:
771 dump_decl (TREE_OPERAND (t, 0), flags);
772 pp_cxx_left_bracket (cxx_pp);
773 dump_decl (TREE_OPERAND (t, 1), flags);
774 pp_cxx_right_bracket (cxx_pp);
775 break;
776
777 /* So that we can do dump_decl on an aggr type. */
778 case RECORD_TYPE:
779 case UNION_TYPE:
780 case ENUMERAL_TYPE:
781 dump_type (t, flags);
782 break;
783
784 case BIT_NOT_EXPR:
785 /* This is a pseudo destructor call which has not been folded into
786 a PSEUDO_DTOR_EXPR yet. */
787 pp_cxx_complement (cxx_pp);
788 dump_type (TREE_OPERAND (t, 0), flags);
789 break;
790
791 case TYPE_EXPR:
792 gcc_unreachable ();
793 break;
794
795 /* These special cases are duplicated here so that other functions
796 can feed identifiers to error and get them demangled properly. */
797 case IDENTIFIER_NODE:
798 if (IDENTIFIER_TYPENAME_P (t))
799 {
800 pp_cxx_identifier (cxx_pp, "operator");
801 /* Not exactly IDENTIFIER_TYPE_VALUE. */
802 dump_type (TREE_TYPE (t), flags);
803 break;
804 }
805 else
806 pp_cxx_tree_identifier (cxx_pp, t);
807 break;
808
809 case OVERLOAD:
810 if (OVL_CHAIN (t))
811 {
812 t = OVL_CURRENT (t);
813 if (DECL_CLASS_SCOPE_P (t))
814 {
815 dump_type (DECL_CONTEXT (t), flags);
816 pp_cxx_colon_colon (cxx_pp);
817 }
818 else if (DECL_CONTEXT (t))
819 {
820 dump_decl (DECL_CONTEXT (t), flags);
821 pp_cxx_colon_colon (cxx_pp);
822 }
823 dump_decl (DECL_NAME (t), flags);
824 break;
825 }
826
827 /* If there's only one function, just treat it like an ordinary
828 FUNCTION_DECL. */
829 t = OVL_CURRENT (t);
830 /* Fall through. */
831
832 case FUNCTION_DECL:
833 if (! DECL_LANG_SPECIFIC (t))
834 pp_identifier (cxx_pp, "<built-in>");
835 else if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
836 dump_global_iord (t);
837 else
838 dump_function_decl (t, flags);
839 break;
840
841 case TEMPLATE_DECL:
842 dump_template_decl (t, flags);
843 break;
844
845 case TEMPLATE_ID_EXPR:
846 {
847 tree name = TREE_OPERAND (t, 0);
848
849 if (is_overloaded_fn (name))
850 name = DECL_NAME (get_first_fn (name));
851 dump_decl (name, flags);
852 pp_cxx_begin_template_argument_list (cxx_pp);
853 if (TREE_OPERAND (t, 1))
854 dump_template_argument_list (TREE_OPERAND (t, 1), flags);
855 pp_cxx_end_template_argument_list (cxx_pp);
856 }
857 break;
858
859 case LABEL_DECL:
860 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
861 break;
862
863 case CONST_DECL:
864 if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE)
865 || (DECL_INITIAL (t) &&
866 TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_PARM_INDEX))
867 dump_simple_decl (t, TREE_TYPE (t), flags);
868 else if (DECL_NAME (t))
869 dump_decl (DECL_NAME (t), flags);
870 else if (DECL_INITIAL (t))
871 dump_expr (DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS);
872 else
873 pp_identifier (cxx_pp, "<enumerator>");
874 break;
875
876 case USING_DECL:
877 pp_cxx_identifier (cxx_pp, "using");
878 dump_type (USING_DECL_SCOPE (t), flags);
879 pp_cxx_colon_colon (cxx_pp);
880 dump_decl (DECL_NAME (t), flags);
881 break;
882
883 case BASELINK:
884 dump_decl (BASELINK_FUNCTIONS (t), flags);
885 break;
886
887 case NON_DEPENDENT_EXPR:
888 dump_expr (t, flags);
889 break;
890
891 case TEMPLATE_TYPE_PARM:
892 if (flags & TFF_DECL_SPECIFIERS)
893 pp_cxx_declaration (cxx_pp, t);
894 else
895 pp_type_id (cxx_pp, t);
896 break;
897
898 default:
899 pp_unsupported_tree (cxx_pp, t);
900 /* Fall through to error. */
901
902 case ERROR_MARK:
903 pp_identifier (cxx_pp, "<declaration error>");
904 break;
905 }
906 }
907
908 /* Dump a template declaration T under control of FLAGS. This means the
909 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
910
911 static void
912 dump_template_decl (tree t, int flags)
913 {
914 tree orig_parms = DECL_TEMPLATE_PARMS (t);
915 tree parms;
916 int i;
917
918 if (flags & TFF_TEMPLATE_HEADER)
919 {
920 for (parms = orig_parms = nreverse (orig_parms);
921 parms;
922 parms = TREE_CHAIN (parms))
923 {
924 tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
925 int len = TREE_VEC_LENGTH (inner_parms);
926
927 pp_cxx_identifier (cxx_pp, "template");
928 pp_cxx_begin_template_argument_list (cxx_pp);
929
930 /* If we've shown the template prefix, we'd better show the
931 parameters' and decl's type too. */
932 flags |= TFF_DECL_SPECIFIERS;
933
934 for (i = 0; i < len; i++)
935 {
936 if (i)
937 pp_separate_with_comma (cxx_pp);
938 dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags);
939 }
940 pp_cxx_end_template_argument_list (cxx_pp);
941 pp_cxx_whitespace (cxx_pp);
942 }
943 nreverse(orig_parms);
944
945 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
946 /* Say `template<arg> class TT' not just `template<arg> TT'. */
947 pp_cxx_identifier (cxx_pp, "class");
948 }
949
950 if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL)
951 dump_type (TREE_TYPE (t),
952 ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
953 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
954 else if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL)
955 dump_decl (DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
956 else
957 {
958 gcc_assert (TREE_TYPE (t));
959 switch (NEXT_CODE (t))
960 {
961 case METHOD_TYPE:
962 case FUNCTION_TYPE:
963 dump_function_decl (t, flags | TFF_TEMPLATE_NAME);
964 break;
965 default:
966 /* This case can occur with some invalid code. */
967 dump_type (TREE_TYPE (t),
968 (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
969 | (flags & TFF_DECL_SPECIFIERS
970 ? TFF_CLASS_KEY_OR_ENUM : 0));
971 }
972 }
973 }
974
975 /* Pretty print a function decl. There are several ways we want to print a
976 function declaration. The TFF_ bits in FLAGS tells us how to behave.
977 As error can only apply the '#' flag once to give 0 and 1 for V, there
978 is %D which doesn't print the throw specs, and %F which does. */
979
980 static void
981 dump_function_decl (tree t, int flags)
982 {
983 tree fntype;
984 tree parmtypes;
985 tree cname = NULL_TREE;
986 tree template_args = NULL_TREE;
987 tree template_parms = NULL_TREE;
988 int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS;
989
990 if (TREE_CODE (t) == TEMPLATE_DECL)
991 t = DECL_TEMPLATE_RESULT (t);
992
993 /* Pretty print template instantiations only. */
994 if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t))
995 {
996 tree tmpl;
997
998 template_args = DECL_TI_ARGS (t);
999 tmpl = most_general_template (t);
1000 if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL)
1001 {
1002 template_parms = DECL_TEMPLATE_PARMS (tmpl);
1003 t = tmpl;
1004 }
1005 }
1006
1007 fntype = TREE_TYPE (t);
1008 parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t);
1009
1010 if (DECL_CLASS_SCOPE_P (t))
1011 cname = DECL_CONTEXT (t);
1012 /* This is for partially instantiated template methods. */
1013 else if (TREE_CODE (fntype) == METHOD_TYPE)
1014 cname = TREE_TYPE (TREE_VALUE (parmtypes));
1015
1016 if (!(flags & TFF_DECL_SPECIFIERS))
1017 /* OK */;
1018 else if (DECL_STATIC_FUNCTION_P (t))
1019 pp_cxx_identifier (cxx_pp, "static");
1020 else if (DECL_VIRTUAL_P (t))
1021 pp_cxx_identifier (cxx_pp, "virtual");
1022
1023 /* Print the return type? */
1024 if (show_return)
1025 show_return = !DECL_CONV_FN_P (t) && !DECL_CONSTRUCTOR_P (t)
1026 && !DECL_DESTRUCTOR_P (t);
1027 if (show_return)
1028 dump_type_prefix (TREE_TYPE (fntype), flags);
1029
1030 /* Print the function name. */
1031 if (cname)
1032 {
1033 dump_type (cname, flags);
1034 pp_cxx_colon_colon (cxx_pp);
1035 }
1036 else
1037 dump_scope (CP_DECL_CONTEXT (t), flags);
1038
1039 dump_function_name (t, flags);
1040
1041 if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
1042 {
1043 dump_parameters (parmtypes, flags);
1044
1045 if (TREE_CODE (fntype) == METHOD_TYPE)
1046 {
1047 pp_base (cxx_pp)->padding = pp_before;
1048 pp_cxx_cv_qualifier_seq
1049 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))));
1050 }
1051
1052 if (flags & TFF_EXCEPTION_SPECIFICATION)
1053 {
1054 pp_base (cxx_pp)->padding = pp_before;
1055 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (fntype), flags);
1056 }
1057
1058 if (show_return)
1059 dump_type_suffix (TREE_TYPE (fntype), flags);
1060 }
1061
1062 /* If T is a template instantiation, dump the parameter binding. */
1063 if (template_parms != NULL_TREE && template_args != NULL_TREE)
1064 {
1065 pp_cxx_whitespace (cxx_pp);
1066 pp_cxx_left_bracket (cxx_pp);
1067 pp_cxx_identifier (cxx_pp, "with");
1068 pp_cxx_whitespace (cxx_pp);
1069 dump_template_bindings (template_parms, template_args);
1070 pp_cxx_right_bracket (cxx_pp);
1071 }
1072 }
1073
1074 /* Print a parameter list. If this is for a member function, the
1075 member object ptr (and any other hidden args) should have
1076 already been removed. */
1077
1078 static void
1079 dump_parameters (tree parmtypes, int flags)
1080 {
1081 int first;
1082
1083 pp_cxx_left_paren (cxx_pp);
1084
1085 for (first = 1; parmtypes != void_list_node;
1086 parmtypes = TREE_CHAIN (parmtypes))
1087 {
1088 if (!first)
1089 pp_separate_with_comma (cxx_pp);
1090 first = 0;
1091 if (!parmtypes)
1092 {
1093 pp_cxx_identifier (cxx_pp, "...");
1094 break;
1095 }
1096 dump_type (TREE_VALUE (parmtypes), flags);
1097
1098 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
1099 {
1100 pp_cxx_whitespace (cxx_pp);
1101 pp_equal (cxx_pp);
1102 pp_cxx_whitespace (cxx_pp);
1103 dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
1104 }
1105 }
1106
1107 pp_cxx_right_paren (cxx_pp);
1108 }
1109
1110 /* Print an exception specification. T is the exception specification. */
1111
1112 static void
1113 dump_exception_spec (tree t, int flags)
1114 {
1115 if (t)
1116 {
1117 pp_cxx_identifier (cxx_pp, "throw");
1118 pp_cxx_whitespace (cxx_pp);
1119 pp_cxx_left_paren (cxx_pp);
1120 if (TREE_VALUE (t) != NULL_TREE)
1121 while (1)
1122 {
1123 dump_type (TREE_VALUE (t), flags);
1124 t = TREE_CHAIN (t);
1125 if (!t)
1126 break;
1127 pp_separate_with_comma (cxx_pp);
1128 }
1129 pp_cxx_right_paren (cxx_pp);
1130 }
1131 }
1132
1133 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1134 and destructors properly. */
1135
1136 static void
1137 dump_function_name (tree t, int flags)
1138 {
1139 tree name = DECL_NAME (t);
1140
1141 /* We can get here with a decl that was synthesized by language-
1142 independent machinery (e.g. coverage.c) in which case it won't
1143 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1144 will crash. In this case it is safe just to print out the
1145 literal name. */
1146 if (!DECL_LANG_SPECIFIC (t))
1147 {
1148 pp_cxx_tree_identifier (cxx_pp, name);
1149 return;
1150 }
1151
1152 if (TREE_CODE (t) == TEMPLATE_DECL)
1153 t = DECL_TEMPLATE_RESULT (t);
1154
1155 /* Don't let the user see __comp_ctor et al. */
1156 if (DECL_CONSTRUCTOR_P (t)
1157 || DECL_DESTRUCTOR_P (t))
1158 name = constructor_name (DECL_CONTEXT (t));
1159
1160 if (DECL_DESTRUCTOR_P (t))
1161 {
1162 pp_cxx_complement (cxx_pp);
1163 dump_decl (name, TFF_PLAIN_IDENTIFIER);
1164 }
1165 else if (DECL_CONV_FN_P (t))
1166 {
1167 /* This cannot use the hack that the operator's return
1168 type is stashed off of its name because it may be
1169 used for error reporting. In the case of conflicting
1170 declarations, both will have the same name, yet
1171 the types will be different, hence the TREE_TYPE field
1172 of the first name will be clobbered by the second. */
1173 pp_cxx_identifier (cxx_pp, "operator");
1174 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1175 }
1176 else if (IDENTIFIER_OPNAME_P (name))
1177 pp_cxx_tree_identifier (cxx_pp, name);
1178 else
1179 dump_decl (name, flags);
1180
1181 if (DECL_TEMPLATE_INFO (t)
1182 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
1183 && (TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
1184 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
1185 dump_template_parms (DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t), flags);
1186 }
1187
1188 /* Dump the template parameters from the template info INFO under control of
1189 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1190 specialization (partial or complete). For partial specializations we show
1191 the specialized parameter values. For a primary template we show no
1192 decoration. */
1193
1194 static void
1195 dump_template_parms (tree info, int primary, int flags)
1196 {
1197 tree args = info ? TI_ARGS (info) : NULL_TREE;
1198
1199 if (primary && flags & TFF_TEMPLATE_NAME)
1200 return;
1201 flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
1202 pp_cxx_begin_template_argument_list (cxx_pp);
1203
1204 /* Be careful only to print things when we have them, so as not
1205 to crash producing error messages. */
1206 if (args && !primary)
1207 {
1208 int len, ix;
1209
1210 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
1211 args = TREE_VEC_ELT (args, TREE_VEC_LENGTH (args) - 1);
1212
1213 len = TREE_VEC_LENGTH (args);
1214
1215 for (ix = 0; ix != len; ix++)
1216 {
1217 tree arg = TREE_VEC_ELT (args, ix);
1218
1219 if (ix)
1220 pp_separate_with_comma (cxx_pp);
1221
1222 if (!arg)
1223 pp_identifier (cxx_pp, "<template parameter error>");
1224 else
1225 dump_template_argument (arg, flags);
1226 }
1227 }
1228 else if (primary)
1229 {
1230 tree tpl = TI_TEMPLATE (info);
1231 tree parms = DECL_TEMPLATE_PARMS (tpl);
1232 int len, ix;
1233
1234 parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE;
1235 len = parms ? TREE_VEC_LENGTH (parms) : 0;
1236
1237 for (ix = 0; ix != len; ix++)
1238 {
1239 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
1240
1241 if (ix)
1242 pp_separate_with_comma (cxx_pp);
1243
1244 dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS);
1245 }
1246 }
1247 pp_cxx_end_template_argument_list (cxx_pp);
1248 }
1249
1250 /* Print out a list of initializers (subr of dump_expr). */
1251
1252 static void
1253 dump_expr_list (tree l, int flags)
1254 {
1255 while (l)
1256 {
1257 dump_expr (TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
1258 l = TREE_CHAIN (l);
1259 if (l)
1260 pp_separate_with_comma (cxx_pp);
1261 }
1262 }
1263
1264 /* Print out a vector of initializers (subr of dump_expr). */
1265
1266 static void
1267 dump_expr_init_vec (VEC(constructor_elt,gc) *v, int flags)
1268 {
1269 unsigned HOST_WIDE_INT idx;
1270 tree value;
1271
1272 FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
1273 {
1274 dump_expr (value, flags | TFF_EXPR_IN_PARENS);
1275 if (idx != VEC_length (constructor_elt, v) - 1)
1276 pp_separate_with_comma (cxx_pp);
1277 }
1278 }
1279
1280
1281 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1282 function. Resolve it to a close relative -- in the sense of static
1283 type -- variant being overridden. That is close to what was written in
1284 the source code. Subroutine of dump_expr. */
1285
1286 static tree
1287 resolve_virtual_fun_from_obj_type_ref (tree ref)
1288 {
1289 tree obj_type = TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref));
1290 int index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1);
1291 tree fun = BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type)));
1292 while (index--)
1293 fun = TREE_CHAIN (fun);
1294
1295 return BV_FN (fun);
1296 }
1297
1298 /* Print out an expression E under control of FLAGS. */
1299
1300 static void
1301 dump_expr (tree t, int flags)
1302 {
1303 if (t == 0)
1304 return;
1305
1306 switch (TREE_CODE (t))
1307 {
1308 case VAR_DECL:
1309 case PARM_DECL:
1310 case FIELD_DECL:
1311 case CONST_DECL:
1312 case FUNCTION_DECL:
1313 case TEMPLATE_DECL:
1314 case NAMESPACE_DECL:
1315 case LABEL_DECL:
1316 case OVERLOAD:
1317 case IDENTIFIER_NODE:
1318 dump_decl (t, (flags & ~TFF_DECL_SPECIFIERS) | TFF_NO_FUNCTION_ARGUMENTS);
1319 break;
1320
1321 case STRING_CST:
1322 if (PAREN_STRING_LITERAL_P (t))
1323 pp_cxx_left_paren (cxx_pp);
1324 pp_c_constant (pp_c_base (cxx_pp), t);
1325 if (PAREN_STRING_LITERAL_P (t))
1326 pp_cxx_right_paren (cxx_pp);
1327 break;
1328
1329 case INTEGER_CST:
1330 case REAL_CST:
1331 pp_c_constant (pp_c_base (cxx_pp), t);
1332 break;
1333
1334 case THROW_EXPR:
1335 pp_cxx_identifier (cxx_pp, "throw");
1336 dump_expr (TREE_OPERAND (t, 0), flags);
1337 break;
1338
1339 case PTRMEM_CST:
1340 pp_ampersand (cxx_pp);
1341 dump_type (PTRMEM_CST_CLASS (t), flags);
1342 pp_cxx_colon_colon (cxx_pp);
1343 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
1344 break;
1345
1346 case COMPOUND_EXPR:
1347 pp_cxx_left_paren (cxx_pp);
1348 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1349 pp_separate_with_comma (cxx_pp);
1350 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1351 pp_cxx_right_paren (cxx_pp);
1352 break;
1353
1354 case COND_EXPR:
1355 pp_cxx_left_paren (cxx_pp);
1356 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1357 pp_string (cxx_pp, " ? ");
1358 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1359 pp_string (cxx_pp, " : ");
1360 dump_expr (TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
1361 pp_cxx_right_paren (cxx_pp);
1362 break;
1363
1364 case SAVE_EXPR:
1365 if (TREE_HAS_CONSTRUCTOR (t))
1366 {
1367 pp_cxx_identifier (cxx_pp, "new");
1368 pp_cxx_whitespace (cxx_pp);
1369 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1370 }
1371 else
1372 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1373 break;
1374
1375 case AGGR_INIT_EXPR:
1376 {
1377 tree fn = NULL_TREE;
1378
1379 if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR)
1380 fn = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
1381
1382 if (fn && TREE_CODE (fn) == FUNCTION_DECL)
1383 {
1384 if (DECL_CONSTRUCTOR_P (fn))
1385 dump_type (DECL_CONTEXT (fn), flags);
1386 else
1387 dump_decl (fn, 0);
1388 }
1389 else
1390 dump_expr (TREE_OPERAND (t, 0), 0);
1391 }
1392 pp_cxx_left_paren (cxx_pp);
1393 if (TREE_OPERAND (t, 1))
1394 dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags);
1395 pp_cxx_right_paren (cxx_pp);
1396 break;
1397
1398 case CALL_EXPR:
1399 {
1400 tree fn = TREE_OPERAND (t, 0);
1401 tree args = TREE_OPERAND (t, 1);
1402
1403 if (TREE_CODE (fn) == ADDR_EXPR)
1404 fn = TREE_OPERAND (fn, 0);
1405
1406 /* Nobody is interested in seeing the guts of vcalls. */
1407 if (TREE_CODE (fn) == OBJ_TYPE_REF)
1408 fn = resolve_virtual_fun_from_obj_type_ref (fn);
1409
1410 if (TREE_TYPE (fn) != NULL_TREE && NEXT_CODE (fn) == METHOD_TYPE)
1411 {
1412 tree ob = TREE_VALUE (args);
1413 if (TREE_CODE (ob) == ADDR_EXPR)
1414 {
1415 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1416 pp_dot (cxx_pp);
1417 }
1418 else if (TREE_CODE (ob) != PARM_DECL
1419 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1420 {
1421 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1422 pp_arrow (cxx_pp);
1423 }
1424 args = TREE_CHAIN (args);
1425 }
1426 dump_expr (fn, flags | TFF_EXPR_IN_PARENS);
1427 pp_cxx_left_paren (cxx_pp);
1428 dump_expr_list (args, flags);
1429 pp_cxx_right_paren (cxx_pp);
1430 }
1431 break;
1432
1433 case NEW_EXPR:
1434 {
1435 tree type = TREE_OPERAND (t, 1);
1436 tree init = TREE_OPERAND (t, 2);
1437 if (NEW_EXPR_USE_GLOBAL (t))
1438 pp_cxx_colon_colon (cxx_pp);
1439 pp_cxx_identifier (cxx_pp, "new");
1440 if (TREE_OPERAND (t, 0))
1441 {
1442 pp_cxx_left_paren (cxx_pp);
1443 dump_expr_list (TREE_OPERAND (t, 0), flags);
1444 pp_cxx_right_paren (cxx_pp);
1445 pp_cxx_whitespace (cxx_pp);
1446 }
1447 if (TREE_CODE (type) == ARRAY_REF)
1448 type = build_cplus_array_type
1449 (TREE_OPERAND (type, 0),
1450 build_index_type (fold_build2 (MINUS_EXPR, integer_type_node,
1451 TREE_OPERAND (type, 1),
1452 integer_one_node)));
1453 dump_type (type, flags);
1454 if (init)
1455 {
1456 pp_cxx_left_paren (cxx_pp);
1457 if (TREE_CODE (init) == TREE_LIST)
1458 dump_expr_list (init, flags);
1459 else if (init == void_zero_node)
1460 /* This representation indicates an empty initializer,
1461 e.g.: "new int()". */
1462 ;
1463 else
1464 dump_expr (init, flags);
1465 pp_cxx_right_paren (cxx_pp);
1466 }
1467 }
1468 break;
1469
1470 case TARGET_EXPR:
1471 /* Note that this only works for G++ target exprs. If somebody
1472 builds a general TARGET_EXPR, there's no way to represent that
1473 it initializes anything other that the parameter slot for the
1474 default argument. Note we may have cleared out the first
1475 operand in expand_expr, so don't go killing ourselves. */
1476 if (TREE_OPERAND (t, 1))
1477 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1478 break;
1479
1480 case INIT_EXPR:
1481 case MODIFY_EXPR:
1482 case PLUS_EXPR:
1483 case MINUS_EXPR:
1484 case MULT_EXPR:
1485 case TRUNC_DIV_EXPR:
1486 case TRUNC_MOD_EXPR:
1487 case MIN_EXPR:
1488 case MAX_EXPR:
1489 case LSHIFT_EXPR:
1490 case RSHIFT_EXPR:
1491 case BIT_IOR_EXPR:
1492 case BIT_XOR_EXPR:
1493 case BIT_AND_EXPR:
1494 case TRUTH_ANDIF_EXPR:
1495 case TRUTH_ORIF_EXPR:
1496 case LT_EXPR:
1497 case LE_EXPR:
1498 case GT_EXPR:
1499 case GE_EXPR:
1500 case EQ_EXPR:
1501 case NE_EXPR:
1502 case EXACT_DIV_EXPR:
1503 dump_binary_op (operator_name_info[(int) TREE_CODE (t)].name, t, flags);
1504 break;
1505
1506 case CEIL_DIV_EXPR:
1507 case FLOOR_DIV_EXPR:
1508 case ROUND_DIV_EXPR:
1509 case RDIV_EXPR:
1510 dump_binary_op ("/", t, flags);
1511 break;
1512
1513 case CEIL_MOD_EXPR:
1514 case FLOOR_MOD_EXPR:
1515 case ROUND_MOD_EXPR:
1516 dump_binary_op ("%", t, flags);
1517 break;
1518
1519 case COMPONENT_REF:
1520 {
1521 tree ob = TREE_OPERAND (t, 0);
1522 if (TREE_CODE (ob) == INDIRECT_REF)
1523 {
1524 ob = TREE_OPERAND (ob, 0);
1525 if (TREE_CODE (ob) != PARM_DECL
1526 || (DECL_NAME (ob)
1527 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this")))
1528 {
1529 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1530 pp_cxx_arrow (cxx_pp);
1531 }
1532 }
1533 else
1534 {
1535 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1536 pp_cxx_dot (cxx_pp);
1537 }
1538 dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
1539 }
1540 break;
1541
1542 case ARRAY_REF:
1543 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1544 pp_cxx_left_bracket (cxx_pp);
1545 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1546 pp_cxx_right_bracket (cxx_pp);
1547 break;
1548
1549 case UNARY_PLUS_EXPR:
1550 dump_unary_op ("+", t, flags);
1551 break;
1552
1553 case ADDR_EXPR:
1554 if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
1555 || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
1556 /* An ADDR_EXPR can have reference type. In that case, we
1557 shouldn't print the `&' doing so indicates to the user
1558 that the expression has pointer type. */
1559 || (TREE_TYPE (t)
1560 && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
1561 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1562 else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL)
1563 dump_unary_op ("&&", t, flags);
1564 else
1565 dump_unary_op ("&", t, flags);
1566 break;
1567
1568 case INDIRECT_REF:
1569 if (TREE_HAS_CONSTRUCTOR (t))
1570 {
1571 t = TREE_OPERAND (t, 0);
1572 gcc_assert (TREE_CODE (t) == CALL_EXPR);
1573 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1574 pp_cxx_left_paren (cxx_pp);
1575 dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags);
1576 pp_cxx_right_paren (cxx_pp);
1577 }
1578 else
1579 {
1580 if (TREE_OPERAND (t,0) != NULL_TREE
1581 && TREE_TYPE (TREE_OPERAND (t, 0))
1582 && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
1583 dump_expr (TREE_OPERAND (t, 0), flags);
1584 else
1585 dump_unary_op ("*", t, flags);
1586 }
1587 break;
1588
1589 case NEGATE_EXPR:
1590 case BIT_NOT_EXPR:
1591 case TRUTH_NOT_EXPR:
1592 case PREDECREMENT_EXPR:
1593 case PREINCREMENT_EXPR:
1594 dump_unary_op (operator_name_info [(int)TREE_CODE (t)].name, t, flags);
1595 break;
1596
1597 case POSTDECREMENT_EXPR:
1598 case POSTINCREMENT_EXPR:
1599 pp_cxx_left_paren (cxx_pp);
1600 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1601 pp_cxx_identifier (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name);
1602 pp_cxx_right_paren (cxx_pp);
1603 break;
1604
1605 case NON_LVALUE_EXPR:
1606 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
1607 should be another level of INDIRECT_REF so that I don't have to do
1608 this. */
1609 if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
1610 {
1611 tree next = TREE_TYPE (TREE_TYPE (t));
1612
1613 while (TREE_CODE (next) == POINTER_TYPE)
1614 next = TREE_TYPE (next);
1615
1616 if (TREE_CODE (next) == FUNCTION_TYPE)
1617 {
1618 if (flags & TFF_EXPR_IN_PARENS)
1619 pp_cxx_left_paren (cxx_pp);
1620 pp_cxx_star (cxx_pp);
1621 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1622 if (flags & TFF_EXPR_IN_PARENS)
1623 pp_cxx_right_paren (cxx_pp);
1624 break;
1625 }
1626 /* Else fall through. */
1627 }
1628 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1629 break;
1630
1631 case NOP_EXPR:
1632 case CONVERT_EXPR:
1633 {
1634 tree op = TREE_OPERAND (t, 0);
1635
1636 if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
1637 {
1638 /* It is a cast, but we cannot tell whether it is a
1639 reinterpret or static cast. Use the C style notation. */
1640 if (flags & TFF_EXPR_IN_PARENS)
1641 pp_cxx_left_paren (cxx_pp);
1642 pp_cxx_left_paren (cxx_pp);
1643 dump_type (TREE_TYPE (t), flags);
1644 pp_cxx_right_paren (cxx_pp);
1645 dump_expr (op, flags | TFF_EXPR_IN_PARENS);
1646 if (flags & TFF_EXPR_IN_PARENS)
1647 pp_cxx_right_paren (cxx_pp);
1648 }
1649 else
1650 dump_expr (op, flags);
1651 break;
1652 }
1653
1654 case CONSTRUCTOR:
1655 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
1656 {
1657 tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
1658
1659 if (integer_zerop (idx))
1660 {
1661 /* A NULL pointer-to-member constant. */
1662 pp_cxx_left_paren (cxx_pp);
1663 pp_cxx_left_paren (cxx_pp);
1664 dump_type (TREE_TYPE (t), flags);
1665 pp_cxx_right_paren (cxx_pp);
1666 pp_character (cxx_pp, '0');
1667 pp_cxx_right_paren (cxx_pp);
1668 break;
1669 }
1670 else if (host_integerp (idx, 0))
1671 {
1672 tree virtuals;
1673 unsigned HOST_WIDE_INT n;
1674
1675 t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
1676 t = TYPE_METHOD_BASETYPE (t);
1677 virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));
1678
1679 n = tree_low_cst (idx, 0);
1680
1681 /* Map vtable index back one, to allow for the null pointer to
1682 member. */
1683 --n;
1684
1685 while (n > 0 && virtuals)
1686 {
1687 --n;
1688 virtuals = TREE_CHAIN (virtuals);
1689 }
1690 if (virtuals)
1691 {
1692 dump_expr (BV_FN (virtuals),
1693 flags | TFF_EXPR_IN_PARENS);
1694 break;
1695 }
1696 }
1697 }
1698 if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (t))
1699 {
1700 dump_type (TREE_TYPE (t), 0);
1701 pp_cxx_left_paren (cxx_pp);
1702 pp_cxx_right_paren (cxx_pp);
1703 }
1704 else
1705 {
1706 pp_cxx_left_brace (cxx_pp);
1707 dump_expr_init_vec (CONSTRUCTOR_ELTS (t), flags);
1708 pp_cxx_right_brace (cxx_pp);
1709 }
1710
1711 break;
1712
1713 case OFFSET_REF:
1714 {
1715 tree ob = TREE_OPERAND (t, 0);
1716 if (is_dummy_object (ob))
1717 {
1718 t = TREE_OPERAND (t, 1);
1719 if (TREE_CODE (t) == FUNCTION_DECL)
1720 /* A::f */
1721 dump_expr (t, flags | TFF_EXPR_IN_PARENS);
1722 else if (BASELINK_P (t))
1723 dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)),
1724 flags | TFF_EXPR_IN_PARENS);
1725 else
1726 dump_decl (t, flags);
1727 }
1728 else
1729 {
1730 if (TREE_CODE (ob) == INDIRECT_REF)
1731 {
1732 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1733 pp_cxx_arrow (cxx_pp);
1734 pp_cxx_star (cxx_pp);
1735 }
1736 else
1737 {
1738 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1739 pp_cxx_dot (cxx_pp);
1740 pp_cxx_star (cxx_pp);
1741 }
1742 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1743 }
1744 break;
1745 }
1746
1747 case TEMPLATE_PARM_INDEX:
1748 dump_decl (TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
1749 break;
1750
1751 case SCOPE_REF:
1752 pp_expression (cxx_pp, t);
1753 break;
1754
1755 case CAST_EXPR:
1756 if (TREE_OPERAND (t, 0) == NULL_TREE
1757 || TREE_CHAIN (TREE_OPERAND (t, 0)))
1758 {
1759 dump_type (TREE_TYPE (t), flags);
1760 pp_cxx_left_paren (cxx_pp);
1761 dump_expr_list (TREE_OPERAND (t, 0), flags);
1762 pp_cxx_right_paren (cxx_pp);
1763 }
1764 else
1765 {
1766 pp_cxx_left_paren (cxx_pp);
1767 dump_type (TREE_TYPE (t), flags);
1768 pp_cxx_right_paren (cxx_pp);
1769 pp_cxx_left_paren (cxx_pp);
1770 dump_expr_list (TREE_OPERAND (t, 0), flags);
1771 pp_cxx_right_paren (cxx_pp);
1772 }
1773 break;
1774
1775 case STATIC_CAST_EXPR:
1776 pp_cxx_identifier (cxx_pp, "static_cast");
1777 goto cast;
1778 case REINTERPRET_CAST_EXPR:
1779 pp_cxx_identifier (cxx_pp, "reinterpret_cast");
1780 goto cast;
1781 case CONST_CAST_EXPR:
1782 pp_cxx_identifier (cxx_pp, "const_cast");
1783 goto cast;
1784 case DYNAMIC_CAST_EXPR:
1785 pp_cxx_identifier (cxx_pp, "dynamic_cast");
1786 cast:
1787 pp_cxx_begin_template_argument_list (cxx_pp);
1788 dump_type (TREE_TYPE (t), flags);
1789 pp_cxx_end_template_argument_list (cxx_pp);
1790 pp_cxx_left_paren (cxx_pp);
1791 dump_expr (TREE_OPERAND (t, 0), flags);
1792 pp_cxx_right_paren (cxx_pp);
1793 break;
1794
1795 case ARROW_EXPR:
1796 dump_expr (TREE_OPERAND (t, 0), flags);
1797 pp_cxx_arrow (cxx_pp);
1798 break;
1799
1800 case SIZEOF_EXPR:
1801 case ALIGNOF_EXPR:
1802 if (TREE_CODE (t) == SIZEOF_EXPR)
1803 pp_cxx_identifier (cxx_pp, "sizeof");
1804 else
1805 {
1806 gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR);
1807 pp_cxx_identifier (cxx_pp, "__alignof__");
1808 }
1809 pp_cxx_whitespace (cxx_pp);
1810 pp_cxx_left_paren (cxx_pp);
1811 if (TYPE_P (TREE_OPERAND (t, 0)))
1812 dump_type (TREE_OPERAND (t, 0), flags);
1813 else
1814 dump_expr (TREE_OPERAND (t, 0), flags);
1815 pp_cxx_right_paren (cxx_pp);
1816 break;
1817
1818 case REALPART_EXPR:
1819 case IMAGPART_EXPR:
1820 pp_cxx_identifier (cxx_pp, operator_name_info[TREE_CODE (t)].name);
1821 pp_cxx_whitespace (cxx_pp);
1822 dump_expr (TREE_OPERAND (t, 0), flags);
1823 break;
1824
1825 case DEFAULT_ARG:
1826 pp_identifier (cxx_pp, "<unparsed>");
1827 break;
1828
1829 case TRY_CATCH_EXPR:
1830 case WITH_CLEANUP_EXPR:
1831 case CLEANUP_POINT_EXPR:
1832 dump_expr (TREE_OPERAND (t, 0), flags);
1833 break;
1834
1835 case PSEUDO_DTOR_EXPR:
1836 dump_expr (TREE_OPERAND (t, 2), flags);
1837 pp_cxx_dot (cxx_pp);
1838 dump_type (TREE_OPERAND (t, 0), flags);
1839 pp_cxx_colon_colon (cxx_pp);
1840 pp_cxx_complement (cxx_pp);
1841 dump_type (TREE_OPERAND (t, 1), flags);
1842 break;
1843
1844 case TEMPLATE_ID_EXPR:
1845 dump_decl (t, flags);
1846 break;
1847
1848 case BIND_EXPR:
1849 case STMT_EXPR:
1850 case STATEMENT_LIST:
1851 /* We don't yet have a way of dumping statements in a
1852 human-readable format. */
1853 pp_string (cxx_pp, "({...})");
1854 break;
1855
1856 case LOOP_EXPR:
1857 pp_string (cxx_pp, "while (1) { ");
1858 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1859 pp_cxx_right_brace (cxx_pp);
1860 break;
1861
1862 case EXIT_EXPR:
1863 pp_string (cxx_pp, "if (");
1864 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1865 pp_string (cxx_pp, ") break; ");
1866 break;
1867
1868 case BASELINK:
1869 dump_expr (get_first_fn (t), flags & ~TFF_EXPR_IN_PARENS);
1870 break;
1871
1872 case EMPTY_CLASS_EXPR:
1873 dump_type (TREE_TYPE (t), flags);
1874 pp_cxx_left_paren (cxx_pp);
1875 pp_cxx_right_paren (cxx_pp);
1876 break;
1877
1878 case NON_DEPENDENT_EXPR:
1879 dump_expr (TREE_OPERAND (t, 0), flags);
1880 break;
1881
1882 /* This list is incomplete, but should suffice for now.
1883 It is very important that `sorry' does not call
1884 `report_error_function'. That could cause an infinite loop. */
1885 default:
1886 pp_unsupported_tree (cxx_pp, t);
1887 /* fall through to ERROR_MARK... */
1888 case ERROR_MARK:
1889 pp_identifier (cxx_pp, "<expression error>");
1890 break;
1891 }
1892 }
1893
1894 static void
1895 dump_binary_op (const char *opstring, tree t, int flags)
1896 {
1897 pp_cxx_left_paren (cxx_pp);
1898 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1899 pp_cxx_whitespace (cxx_pp);
1900 if (opstring)
1901 pp_cxx_identifier (cxx_pp, opstring);
1902 else
1903 pp_identifier (cxx_pp, "<unknown operator>");
1904 pp_cxx_whitespace (cxx_pp);
1905 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1906 pp_cxx_right_paren (cxx_pp);
1907 }
1908
1909 static void
1910 dump_unary_op (const char *opstring, tree t, int flags)
1911 {
1912 if (flags & TFF_EXPR_IN_PARENS)
1913 pp_cxx_left_paren (cxx_pp);
1914 pp_cxx_identifier (cxx_pp, opstring);
1915 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1916 if (flags & TFF_EXPR_IN_PARENS)
1917 pp_cxx_right_paren (cxx_pp);
1918 }
1919
1920 static void
1921 reinit_cxx_pp (void)
1922 {
1923 pp_clear_output_area (cxx_pp);
1924 pp_base (cxx_pp)->padding = pp_none;
1925 pp_indentation (cxx_pp) = 0;
1926 pp_needs_newline (cxx_pp) = false;
1927 cxx_pp->enclosing_scope = 0;
1928 }
1929
1930
1931 /* Exported interface to stringifying types, exprs and decls under TFF_*
1932 control. */
1933
1934 const char *
1935 type_as_string (tree typ, int flags)
1936 {
1937 reinit_cxx_pp ();
1938 dump_type (typ, flags);
1939 return pp_formatted_text (cxx_pp);
1940 }
1941
1942 const char *
1943 expr_as_string (tree decl, int flags)
1944 {
1945 reinit_cxx_pp ();
1946 dump_expr (decl, flags);
1947 return pp_formatted_text (cxx_pp);
1948 }
1949
1950 const char *
1951 decl_as_string (tree decl, int flags)
1952 {
1953 reinit_cxx_pp ();
1954 dump_decl (decl, flags);
1955 return pp_formatted_text (cxx_pp);
1956 }
1957
1958 /* Generate the three forms of printable names for cxx_printable_name. */
1959
1960 const char *
1961 lang_decl_name (tree decl, int v)
1962 {
1963 if (v >= 2)
1964 return decl_as_string (decl, TFF_DECL_SPECIFIERS);
1965
1966 reinit_cxx_pp ();
1967 if (v == 1 && DECL_CLASS_SCOPE_P (decl))
1968 {
1969 dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
1970 pp_cxx_colon_colon (cxx_pp);
1971 }
1972
1973 if (TREE_CODE (decl) == FUNCTION_DECL)
1974 dump_function_name (decl, TFF_PLAIN_IDENTIFIER);
1975 else
1976 dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
1977
1978 return pp_formatted_text (cxx_pp);
1979 }
1980
1981 /* Return the location of a tree passed to %+ formats. */
1982
1983 static location_t
1984 location_of (tree t)
1985 {
1986 if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
1987 t = DECL_CONTEXT (t);
1988 else if (TYPE_P (t))
1989 t = TYPE_MAIN_DECL (t);
1990 else if (TREE_CODE (t) == OVERLOAD)
1991 t = OVL_FUNCTION (t);
1992
1993 return DECL_SOURCE_LOCATION (t);
1994 }
1995
1996 /* Now the interfaces from error et al to dump_type et al. Each takes an
1997 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
1998 function. */
1999
2000 static const char *
2001 decl_to_string (tree decl, int verbose)
2002 {
2003 int flags = 0;
2004
2005 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
2006 || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
2007 flags = TFF_CLASS_KEY_OR_ENUM;
2008 if (verbose)
2009 flags |= TFF_DECL_SPECIFIERS;
2010 else if (TREE_CODE (decl) == FUNCTION_DECL)
2011 flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
2012 flags |= TFF_TEMPLATE_HEADER;
2013
2014 reinit_cxx_pp ();
2015 dump_decl (decl, flags);
2016 return pp_formatted_text (cxx_pp);
2017 }
2018
2019 static const char *
2020 expr_to_string (tree decl)
2021 {
2022 reinit_cxx_pp ();
2023 dump_expr (decl, 0);
2024 return pp_formatted_text (cxx_pp);
2025 }
2026
2027 static const char *
2028 fndecl_to_string (tree fndecl, int verbose)
2029 {
2030 int flags;
2031
2032 flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS
2033 | TFF_TEMPLATE_HEADER;
2034 if (verbose)
2035 flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
2036 reinit_cxx_pp ();
2037 dump_decl (fndecl, flags);
2038 return pp_formatted_text (cxx_pp);
2039 }
2040
2041
2042 static const char *
2043 code_to_string (enum tree_code c)
2044 {
2045 return tree_code_name [c];
2046 }
2047
2048 const char *
2049 language_to_string (enum languages c)
2050 {
2051 switch (c)
2052 {
2053 case lang_c:
2054 return "C";
2055
2056 case lang_cplusplus:
2057 return "C++";
2058
2059 case lang_java:
2060 return "Java";
2061
2062 default:
2063 gcc_unreachable ();
2064 }
2065 return 0;
2066 }
2067
2068 /* Return the proper printed version of a parameter to a C++ function. */
2069
2070 static const char *
2071 parm_to_string (int p)
2072 {
2073 reinit_cxx_pp ();
2074 if (p < 0)
2075 pp_string (cxx_pp, "'this'");
2076 else
2077 pp_decimal_int (cxx_pp, p + 1);
2078 return pp_formatted_text (cxx_pp);
2079 }
2080
2081 static const char *
2082 op_to_string (enum tree_code p)
2083 {
2084 tree id = operator_name_info[(int) p].identifier;
2085 return id ? IDENTIFIER_POINTER (id) : "<unknown>";
2086 }
2087
2088 static const char *
2089 type_to_string (tree typ, int verbose)
2090 {
2091 int flags = 0;
2092 if (verbose)
2093 flags |= TFF_CLASS_KEY_OR_ENUM;
2094 flags |= TFF_TEMPLATE_HEADER;
2095
2096 reinit_cxx_pp ();
2097 dump_type (typ, flags);
2098 return pp_formatted_text (cxx_pp);
2099 }
2100
2101 static const char *
2102 assop_to_string (enum tree_code p)
2103 {
2104 tree id = assignment_operator_name_info[(int) p].identifier;
2105 return id ? IDENTIFIER_POINTER (id) : "{unknown}";
2106 }
2107
2108 static const char *
2109 args_to_string (tree p, int verbose)
2110 {
2111 int flags = 0;
2112 if (verbose)
2113 flags |= TFF_CLASS_KEY_OR_ENUM;
2114
2115 if (p == NULL_TREE)
2116 return "";
2117
2118 if (TYPE_P (TREE_VALUE (p)))
2119 return type_as_string (p, flags);
2120
2121 reinit_cxx_pp ();
2122 for (; p; p = TREE_CHAIN (p))
2123 {
2124 if (TREE_VALUE (p) == null_node)
2125 pp_cxx_identifier (cxx_pp, "NULL");
2126 else
2127 dump_type (error_type (TREE_VALUE (p)), flags);
2128 if (TREE_CHAIN (p))
2129 pp_separate_with_comma (cxx_pp);
2130 }
2131 return pp_formatted_text (cxx_pp);
2132 }
2133
2134 static const char *
2135 cv_to_string (tree p, int v)
2136 {
2137 reinit_cxx_pp ();
2138 pp_base (cxx_pp)->padding = v ? pp_before : pp_none;
2139 pp_cxx_cv_qualifier_seq (cxx_pp, p);
2140 return pp_formatted_text (cxx_pp);
2141 }
2142
2143 /* Langhook for print_error_function. */
2144 void
2145 cxx_print_error_function (diagnostic_context *context, const char *file)
2146 {
2147 lhd_print_error_function (context, file);
2148 pp_base_set_prefix (context->printer, file);
2149 maybe_print_instantiation_context (context);
2150 }
2151
2152 static void
2153 cp_diagnostic_starter (diagnostic_context *context,
2154 diagnostic_info *diagnostic)
2155 {
2156 diagnostic_report_current_module (context);
2157 cp_print_error_function (context, diagnostic);
2158 maybe_print_instantiation_context (context);
2159 pp_base_set_prefix (context->printer, diagnostic_build_prefix (diagnostic));
2160 }
2161
2162 static void
2163 cp_diagnostic_finalizer (diagnostic_context *context,
2164 diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
2165 {
2166 pp_base_destroy_prefix (context->printer);
2167 }
2168
2169 /* Print current function onto BUFFER, in the process of reporting
2170 a diagnostic message. Called from cp_diagnostic_starter. */
2171 static void
2172 cp_print_error_function (diagnostic_context *context,
2173 diagnostic_info *diagnostic)
2174 {
2175 if (diagnostic_last_function_changed (context))
2176 {
2177 const char *old_prefix = context->printer->prefix;
2178 const char *file = LOCATION_FILE (diagnostic->location);
2179 char *new_prefix = file ? file_name_as_prefix (file) : NULL;
2180
2181 pp_base_set_prefix (context->printer, new_prefix);
2182
2183 if (current_function_decl == NULL)
2184 pp_base_string (context->printer, "At global scope:");
2185 else
2186 pp_printf (context->printer, "In %s %qs:",
2187 function_category (current_function_decl),
2188 cxx_printable_name (current_function_decl, 2));
2189 pp_base_newline (context->printer);
2190
2191 diagnostic_set_last_function (context);
2192 pp_base_destroy_prefix (context->printer);
2193 context->printer->prefix = old_prefix;
2194 }
2195 }
2196
2197 /* Returns a description of FUNCTION using standard terminology. */
2198 static const char *
2199 function_category (tree fn)
2200 {
2201 if (DECL_FUNCTION_MEMBER_P (fn))
2202 {
2203 if (DECL_STATIC_FUNCTION_P (fn))
2204 return "static member function";
2205 else if (DECL_COPY_CONSTRUCTOR_P (fn))
2206 return "copy constructor";
2207 else if (DECL_CONSTRUCTOR_P (fn))
2208 return "constructor";
2209 else if (DECL_DESTRUCTOR_P (fn))
2210 return "destructor";
2211 else
2212 return "member function";
2213 }
2214 else
2215 return "function";
2216 }
2217
2218 /* Report the full context of a current template instantiation,
2219 onto BUFFER. */
2220 static void
2221 print_instantiation_full_context (diagnostic_context *context)
2222 {
2223 tree p = current_instantiation ();
2224 location_t location = input_location;
2225
2226 if (p)
2227 {
2228 if (current_function_decl != TINST_DECL (p)
2229 && current_function_decl != NULL_TREE)
2230 /* We can get here during the processing of some synthesized
2231 method. Then, TINST_DECL (p) will be the function that's causing
2232 the synthesis. */
2233 ;
2234 else
2235 {
2236 if (current_function_decl == TINST_DECL (p))
2237 /* Avoid redundancy with the "In function" line. */;
2238 else
2239 pp_verbatim (context->printer,
2240 "%s: In instantiation of %qs:\n",
2241 LOCATION_FILE (location),
2242 decl_as_string (TINST_DECL (p),
2243 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2244
2245 location = TINST_LOCATION (p);
2246 p = TREE_CHAIN (p);
2247 }
2248 }
2249
2250 print_instantiation_partial_context (context, p, location);
2251 }
2252
2253 /* Same as above but less verbose. */
2254 static void
2255 print_instantiation_partial_context (diagnostic_context *context,
2256 tree t, location_t loc)
2257 {
2258 expanded_location xloc;
2259 for (; ; t = TREE_CHAIN (t))
2260 {
2261 xloc = expand_location (loc);
2262 if (t == NULL_TREE)
2263 break;
2264 pp_verbatim (context->printer, "%s:%d: instantiated from %qs\n",
2265 xloc.file, xloc.line,
2266 decl_as_string (TINST_DECL (t),
2267 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2268 loc = TINST_LOCATION (t);
2269 }
2270 pp_verbatim (context->printer, "%s:%d: instantiated from here",
2271 xloc.file, xloc.line);
2272 pp_base_newline (context->printer);
2273 }
2274
2275 /* Called from cp_thing to print the template context for an error. */
2276 static void
2277 maybe_print_instantiation_context (diagnostic_context *context)
2278 {
2279 if (!problematic_instantiation_changed () || current_instantiation () == 0)
2280 return;
2281
2282 record_last_problematic_instantiation ();
2283 print_instantiation_full_context (context);
2284 }
2285
2286 /* Report the bare minimum context of a template instantiation. */
2287 void
2288 print_instantiation_context (void)
2289 {
2290 print_instantiation_partial_context
2291 (global_dc, current_instantiation (), input_location);
2292 diagnostic_flush_buffer (global_dc);
2293 }
2294 \f
2295 /* Called from output_format -- during diagnostic message processing --
2296 to handle C++ specific format specifier with the following meanings:
2297 %A function argument-list.
2298 %C tree code.
2299 %D declaration.
2300 %E expression.
2301 %F function declaration.
2302 %L language as used in extern "lang".
2303 %O binary operator.
2304 %P function parameter whose position is indicated by an integer.
2305 %Q assignment operator.
2306 %T type.
2307 %V cv-qualifier. */
2308 static bool
2309 cp_printer (pretty_printer *pp, text_info *text, const char *spec,
2310 int precision, bool wide, bool set_locus, bool verbose)
2311 {
2312 const char *result;
2313 tree t = NULL;
2314 #define next_tree (t = va_arg (*text->args_ptr, tree))
2315 #define next_tcode va_arg (*text->args_ptr, enum tree_code)
2316 #define next_lang va_arg (*text->args_ptr, enum languages)
2317 #define next_int va_arg (*text->args_ptr, int)
2318
2319 if (precision != 0 || wide)
2320 return false;
2321
2322 if (text->locus == NULL)
2323 set_locus = false;
2324
2325 switch (*spec)
2326 {
2327 case 'A': result = args_to_string (next_tree, verbose); break;
2328 case 'C': result = code_to_string (next_tcode); break;
2329 case 'D': result = decl_to_string (next_tree, verbose); break;
2330 case 'E': result = expr_to_string (next_tree); break;
2331 case 'F': result = fndecl_to_string (next_tree, verbose); break;
2332 case 'L': result = language_to_string (next_lang); break;
2333 case 'O': result = op_to_string (next_tcode); break;
2334 case 'P': result = parm_to_string (next_int); break;
2335 case 'Q': result = assop_to_string (next_tcode); break;
2336 case 'T': result = type_to_string (next_tree, verbose); break;
2337 case 'V': result = cv_to_string (next_tree, verbose); break;
2338
2339 default:
2340 return false;
2341 }
2342
2343 pp_base_string (pp, result);
2344 if (set_locus && t != NULL)
2345 *text->locus = location_of (t);
2346 return true;
2347 #undef next_tree
2348 #undef next_tcode
2349 #undef next_lang
2350 #undef next_int
2351 }
2352 \f
2353 /* Callback from cpp_error for PFILE to print diagnostics arising from
2354 interpreting strings. The diagnostic is of type LEVEL; MSG is the
2355 translated message and AP the arguments. */
2356
2357 void
2358 cp_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level,
2359 const char *msg, va_list *ap)
2360 {
2361 diagnostic_info diagnostic;
2362 diagnostic_t dlevel;
2363 switch (level)
2364 {
2365 case CPP_DL_WARNING:
2366 case CPP_DL_WARNING_SYSHDR:
2367 dlevel = DK_WARNING;
2368 break;
2369 case CPP_DL_PEDWARN:
2370 dlevel = pedantic_error_kind ();
2371 break;
2372 case CPP_DL_ERROR:
2373 dlevel = DK_ERROR;
2374 break;
2375 case CPP_DL_ICE:
2376 dlevel = DK_ICE;
2377 break;
2378 default:
2379 gcc_unreachable ();
2380 }
2381 diagnostic_set_info_translated (&diagnostic, msg, ap,
2382 input_location, dlevel);
2383 report_diagnostic (&diagnostic);
2384 }
Mirror of the offical gcc git repository hosted at gcc.gnu.org