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