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