]> git.ipfire.org Git - thirdparty/gcc.git/blame - gcc/tree-pretty-print.c
projects / thirdparty / gcc.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
gcc/
[thirdparty/gcc.git] / gcc / tree-pretty-print.c
CommitLineData
4ee9c684 1/* Pretty formatting of GENERIC trees in C syntax.
9c85a98a 2 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
4a61a337 3 Free Software Foundation, Inc.
4ee9c684 4 Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>
5
6This file is part of GCC.
7
8GCC is free software; you can redistribute it and/or modify it under
9the terms of the GNU General Public License as published by the Free
8c4c00c1 10Software Foundation; either version 3, or (at your option) any later
4ee9c684 11version.
12
13GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14WARRANTY; without even the implied warranty of MERCHANTABILITY or
15FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16for more details.
17
18You should have received a copy of the GNU General Public License
8c4c00c1 19along with GCC; see the file COPYING3. If not see
20<http://www.gnu.org/licenses/>. */
4ee9c684 21
22#include "config.h"
23#include "system.h"
24#include "coretypes.h"
25#include "tm.h"
4ee9c684 26#include "tree.h"
fd890377 27#include "output.h"
4ee9c684 28#include "diagnostic.h"
29#include "real.h"
30#include "hashtab.h"
31#include "tree-flow.h"
32#include "langhooks.h"
33#include "tree-iterator.h"
101d9422 34#include "tree-chrec.h"
77fce4cd 35#include "tree-pass.h"
06f0b99c 36#include "fixed-value.h"
4992f399 37#include "value-prof.h"
4a1849e3 38#include "predict.h"
4ee9c684 39
40/* Local functions, macros and variables. */
7ecb5bb2 41static int op_prio (const_tree);
b4b34335 42static const char *op_symbol (const_tree);
4ee9c684 43static void pretty_print_string (pretty_printer *, const char*);
b4b34335 44static void print_call_name (pretty_printer *, const_tree);
4ee9c684 45static void newline_and_indent (pretty_printer *, int);
46static void maybe_init_pretty_print (FILE *);
b4b34335 47static void print_struct_decl (pretty_printer *, const_tree, int, int);
48static void do_niy (pretty_printer *, const_tree);
4ee9c684 49
50#define INDENT(SPACE) do { \
51 int i; for (i = 0; i<SPACE; i++) pp_space (buffer); } while (0)
52
53#define NIY do_niy(buffer,node)
54
55#define PRINT_FUNCTION_NAME(NODE) pp_printf \
56 (buffer, "%s", TREE_CODE (NODE) == NOP_EXPR ? \
5135beeb 57 lang_hooks.decl_printable_name (TREE_OPERAND (NODE, 0), 1) : \
58 lang_hooks.decl_printable_name (NODE, 1))
4ee9c684 59
4ee9c684 60static pretty_printer buffer;
61static int initialized = 0;
4ee9c684 62
63/* Try to print something for an unknown tree code. */
64
65static void
b4b34335 66do_niy (pretty_printer *buffer, const_tree node)
4ee9c684 67{
68 int i, len;
69
70 pp_string (buffer, "<<< Unknown tree: ");
71 pp_string (buffer, tree_code_name[(int) TREE_CODE (node)]);
72
ce45a448 73 if (EXPR_P (node))
4ee9c684 74 {
c2f47e15 75 len = TREE_OPERAND_LENGTH (node);
4ee9c684 76 for (i = 0; i < len; ++i)
77 {
78 newline_and_indent (buffer, 2);
79 dump_generic_node (buffer, TREE_OPERAND (node, i), 2, 0, false);
80 }
81 }
82
83 pp_string (buffer, " >>>\n");
84}
85
4726380a 86/* Debugging function to print out a generic expression. */
87
4ee9c684 88void
89debug_generic_expr (tree t)
90{
4fb5e5ca 91 print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS);
4ee9c684 92 fprintf (stderr, "\n");
93}
94
4726380a 95/* Debugging function to print out a generic statement. */
96
4ee9c684 97void
98debug_generic_stmt (tree t)
99{
4fb5e5ca 100 print_generic_stmt (stderr, t, TDF_VOPS|TDF_MEMSYMS);
4ee9c684 101 fprintf (stderr, "\n");
102}
103
4726380a 104/* Debugging function to print out a chain of trees . */
105
1e8e9920 106void
107debug_tree_chain (tree t)
108{
4d735392 109 while (t)
110 {
4fb5e5ca 111 print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID);
4d735392 112 fprintf(stderr, " ");
113 t = TREE_CHAIN (t);
114 }
1e8e9920 115 fprintf (stderr, "\n");
116}
117
4ee9c684 118/* Prints declaration DECL to the FILE with details specified by FLAGS. */
119void
120print_generic_decl (FILE *file, tree decl, int flags)
121{
122 maybe_init_pretty_print (file);
4ee9c684 123 print_declaration (&buffer, decl, 2, flags);
124 pp_write_text_to_stream (&buffer);
125}
126
127/* Print tree T, and its successors, on file FILE. FLAGS specifies details
ba810638 128 to show in the dump. See TDF_* in tree-pass.h. */
4ee9c684 129
130void
131print_generic_stmt (FILE *file, tree t, int flags)
132{
133 maybe_init_pretty_print (file);
4ee9c684 134 dump_generic_node (&buffer, t, 0, flags, true);
135 pp_flush (&buffer);
136}
137
138/* Print tree T, and its successors, on file FILE. FLAGS specifies details
ba810638 139 to show in the dump. See TDF_* in tree-pass.h. The output is indented by
4ee9c684 140 INDENT spaces. */
141
142void
143print_generic_stmt_indented (FILE *file, tree t, int flags, int indent)
144{
145 int i;
146
147 maybe_init_pretty_print (file);
4ee9c684 148
149 for (i = 0; i < indent; i++)
150 pp_space (&buffer);
151 dump_generic_node (&buffer, t, indent, flags, true);
152 pp_flush (&buffer);
153}
154
155/* Print a single expression T on file FILE. FLAGS specifies details to show
ba810638 156 in the dump. See TDF_* in tree-pass.h. */
4ee9c684 157
158void
159print_generic_expr (FILE *file, tree t, int flags)
160{
161 maybe_init_pretty_print (file);
4ee9c684 162 dump_generic_node (&buffer, t, 0, flags, false);
163}
164
165/* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
166 in FLAGS. */
167
168static void
169dump_decl_name (pretty_printer *buffer, tree node, int flags)
170{
1e8e9920 171 tree t = node;
4ee9c684 172
4d735392 173 if (DECL_NAME (t))
174 pp_tree_identifier (buffer, DECL_NAME (t));
175 if ((flags & TDF_UID)
176 || DECL_NAME (t) == NULL_TREE)
4ee9c684 177 {
4d735392 178 if (TREE_CODE (t) == LABEL_DECL
179 && LABEL_DECL_UID (t) != -1)
b4e7b9fe 180 pp_printf (buffer, "L.%d", (int) LABEL_DECL_UID (t));
4d735392 181 else
e67e5e1f 182 {
4d735392 183 char c = TREE_CODE (t) == CONST_DECL ? 'C' : 'D';
184 pp_printf (buffer, "%c.%u", c, DECL_UID (t));
e67e5e1f 185 }
4ee9c684 186 }
187}
188
a1080ab2 189/* Like the above, but used for pretty printing function calls. */
190
191static void
192dump_function_name (pretty_printer *buffer, tree node)
193{
194 if (DECL_NAME (node))
195 PRINT_FUNCTION_NAME (node);
196 else
197 dump_decl_name (buffer, node, 0);
198}
199
d700b485 200/* Dump a function declaration. NODE is the FUNCTION_TYPE. BUFFER, SPC and
201 FLAGS are as in dump_generic_node. */
202
203static void
204dump_function_declaration (pretty_printer *buffer, tree node,
205 int spc, int flags)
206{
207 bool wrote_arg = false;
208 tree arg;
209
210 pp_space (buffer);
211 pp_character (buffer, '(');
212
213 /* Print the argument types. The last element in the list is a VOID_TYPE.
214 The following avoids printing the last element. */
215 arg = TYPE_ARG_TYPES (node);
216 while (arg && TREE_CHAIN (arg) && arg != error_mark_node)
217 {
218 wrote_arg = true;
219 dump_generic_node (buffer, TREE_VALUE (arg), spc, flags, false);
220 arg = TREE_CHAIN (arg);
221 if (TREE_CHAIN (arg) && TREE_CODE (TREE_CHAIN (arg)) == TREE_LIST)
222 {
223 pp_character (buffer, ',');
224 pp_space (buffer);
225 }
226 }
227
228 if (!wrote_arg)
229 pp_string (buffer, "void");
230
231 pp_character (buffer, ')');
232}
233
9b1a6180 234/* Dump the domain associated with an array. */
235
236static void
237dump_array_domain (pretty_printer *buffer, tree domain, int spc, int flags)
238{
239 pp_character (buffer, '[');
240 if (domain)
241 {
242 tree min = TYPE_MIN_VALUE (domain);
243 tree max = TYPE_MAX_VALUE (domain);
244
245 if (min && max
246 && integer_zerop (min)
247 && host_integerp (max, 0))
248 pp_wide_integer (buffer, TREE_INT_CST_LOW (max) + 1);
249 else
250 {
251 if (min)
252 dump_generic_node (buffer, min, spc, flags, false);
253 pp_character (buffer, ':');
254 if (max)
255 dump_generic_node (buffer, max, spc, flags, false);
256 }
257 }
258 else
259 pp_string (buffer, "<unknown>");
260 pp_character (buffer, ']');
261}
262
55d6e7cd 263
264/* Dump OpenMP clause CLAUSE. BUFFER, CLAUSE, SPC and FLAGS are as in
265 dump_generic_node. */
1e8e9920 266
267static void
55d6e7cd 268dump_omp_clause (pretty_printer *buffer, tree clause, int spc, int flags)
1e8e9920 269{
270 const char *name;
271
55d6e7cd 272 switch (OMP_CLAUSE_CODE (clause))
1e8e9920 273 {
55d6e7cd 274 case OMP_CLAUSE_PRIVATE:
275 name = "private";
276 goto print_remap;
277 case OMP_CLAUSE_SHARED:
278 name = "shared";
279 goto print_remap;
280 case OMP_CLAUSE_FIRSTPRIVATE:
281 name = "firstprivate";
282 goto print_remap;
283 case OMP_CLAUSE_LASTPRIVATE:
284 name = "lastprivate";
285 goto print_remap;
286 case OMP_CLAUSE_COPYIN:
287 name = "copyin";
288 goto print_remap;
289 case OMP_CLAUSE_COPYPRIVATE:
290 name = "copyprivate";
291 goto print_remap;
292 print_remap:
293 pp_string (buffer, name);
294 pp_character (buffer, '(');
295 dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),
296 spc, flags, false);
297 pp_character (buffer, ')');
298 break;
1e8e9920 299
55d6e7cd 300 case OMP_CLAUSE_REDUCTION:
301 pp_string (buffer, "reduction(");
ad4a85ad 302 pp_string (buffer, op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause)));
55d6e7cd 303 pp_character (buffer, ':');
304 dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),
305 spc, flags, false);
306 pp_character (buffer, ')');
307 break;
1e8e9920 308
55d6e7cd 309 case OMP_CLAUSE_IF:
310 pp_string (buffer, "if(");
311 dump_generic_node (buffer, OMP_CLAUSE_IF_EXPR (clause),
312 spc, flags, false);
313 pp_character (buffer, ')');
314 break;
1e8e9920 315
55d6e7cd 316 case OMP_CLAUSE_NUM_THREADS:
317 pp_string (buffer, "num_threads(");
318 dump_generic_node (buffer, OMP_CLAUSE_NUM_THREADS_EXPR (clause),
319 spc, flags, false);
320 pp_character (buffer, ')');
321 break;
1e8e9920 322
55d6e7cd 323 case OMP_CLAUSE_NOWAIT:
324 pp_string (buffer, "nowait");
325 break;
326 case OMP_CLAUSE_ORDERED:
327 pp_string (buffer, "ordered");
328 break;
1e8e9920 329
55d6e7cd 330 case OMP_CLAUSE_DEFAULT:
331 pp_string (buffer, "default(");
332 switch (OMP_CLAUSE_DEFAULT_KIND (clause))
333 {
fd6481cf 334 case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
335 break;
336 case OMP_CLAUSE_DEFAULT_SHARED:
337 pp_string (buffer, "shared");
338 break;
339 case OMP_CLAUSE_DEFAULT_NONE:
340 pp_string (buffer, "none");
341 break;
342 case OMP_CLAUSE_DEFAULT_PRIVATE:
343 pp_string (buffer, "private");
344 break;
345 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE:
346 pp_string (buffer, "firstprivate");
347 break;
348 default:
349 gcc_unreachable ();
55d6e7cd 350 }
351 pp_character (buffer, ')');
352 break;
1e8e9920 353
55d6e7cd 354 case OMP_CLAUSE_SCHEDULE:
355 pp_string (buffer, "schedule(");
356 switch (OMP_CLAUSE_SCHEDULE_KIND (clause))
357 {
358 case OMP_CLAUSE_SCHEDULE_STATIC:
359 pp_string (buffer, "static");
360 break;
361 case OMP_CLAUSE_SCHEDULE_DYNAMIC:
362 pp_string (buffer, "dynamic");
363 break;
364 case OMP_CLAUSE_SCHEDULE_GUIDED:
365 pp_string (buffer, "guided");
366 break;
367 case OMP_CLAUSE_SCHEDULE_RUNTIME:
368 pp_string (buffer, "runtime");
369 break;
fd6481cf 370 case OMP_CLAUSE_SCHEDULE_AUTO:
371 pp_string (buffer, "auto");
372 break;
55d6e7cd 373 default:
374 gcc_unreachable ();
1e8e9920 375 }
55d6e7cd 376 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause))
377 {
378 pp_character (buffer, ',');
379 dump_generic_node (buffer,
380 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause),
381 spc, flags, false);
382 }
383 pp_character (buffer, ')');
384 break;
385
fd6481cf 386 case OMP_CLAUSE_UNTIED:
387 pp_string (buffer, "untied");
388 break;
389
390 case OMP_CLAUSE_COLLAPSE:
391 pp_string (buffer, "collapse(");
392 dump_generic_node (buffer,
393 OMP_CLAUSE_COLLAPSE_EXPR (clause),
394 spc, flags, false);
395 pp_character (buffer, ')');
396 break;
397
55d6e7cd 398 default:
399 /* Should never happen. */
400 dump_generic_node (buffer, clause, spc, flags, false);
401 break;
402 }
403}
404
405
406/* Dump the list of OpenMP clauses. BUFFER, SPC and FLAGS are as in
407 dump_generic_node. */
408
75a70cf9 409void
55d6e7cd 410dump_omp_clauses (pretty_printer *buffer, tree clause, int spc, int flags)
411{
412 if (clause == NULL)
413 return;
1e8e9920 414
55d6e7cd 415 pp_space (buffer);
416 while (1)
417 {
418 dump_omp_clause (buffer, clause, spc, flags);
1e8e9920 419 clause = OMP_CLAUSE_CHAIN (clause);
420 if (clause == NULL)
421 return;
422 pp_space (buffer);
423 }
424}
425
55d6e7cd 426
46412a37 427/* Dump the node NODE on the pretty_printer BUFFER, SPC spaces of
428 indent. FLAGS specifies details to show in the dump (see TDF_* in
429 tree-pass.h). If IS_STMT is true, the object printed is considered
430 to be a statement and it is terminated by ';' if appropriate. */
4ee9c684 431
432int
433dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
434 bool is_stmt)
435{
436 tree type;
437 tree op0, op1;
d700b485 438 const char *str;
4ee9c684 439 bool is_expr;
440
441 if (node == NULL_TREE)
442 return spc;
443
75a70cf9 444 is_expr = EXPR_P (node);
4ee9c684 445
22aa74c4 446 if (is_stmt && (flags & TDF_STMTADDR))
f3a60048 447 pp_printf (buffer, "<&%p> ", (void *)node);
22aa74c4 448
1e8e9920 449 if ((flags & TDF_LINENO) && EXPR_HAS_LOCATION (node))
4ee9c684 450 {
7bd3dcc4 451 expanded_location xloc = expand_location (EXPR_LOCATION (node));
4ee9c684 452 pp_character (buffer, '[');
7bd3dcc4 453 if (xloc.file)
4ee9c684 454 {
7bd3dcc4 455 pp_string (buffer, xloc.file);
4ee9c684 456 pp_string (buffer, " : ");
457 }
7bd3dcc4 458 pp_decimal_int (buffer, xloc.line);
4ee9c684 459 pp_string (buffer, "] ");
460 }
461
462 switch (TREE_CODE (node))
463 {
464 case ERROR_MARK:
465 pp_string (buffer, "<<< error >>>");
466 break;
467
468 case IDENTIFIER_NODE:
469 pp_tree_identifier (buffer, node);
470 break;
471
472 case TREE_LIST:
473 while (node && node != error_mark_node)
474 {
475 if (TREE_PURPOSE (node))
476 {
477 dump_generic_node (buffer, TREE_PURPOSE (node), spc, flags, false);
478 pp_space (buffer);
479 }
480 dump_generic_node (buffer, TREE_VALUE (node), spc, flags, false);
481 node = TREE_CHAIN (node);
482 if (node && TREE_CODE (node) == TREE_LIST)
483 {
484 pp_character (buffer, ',');
485 pp_space (buffer);
486 }
487 }
488 break;
489
dce3d064 490 case TREE_BINFO:
4ee9c684 491 dump_generic_node (buffer, BINFO_TYPE (node), spc, flags, false);
dce3d064 492
493 case TREE_VEC:
494 {
495 size_t i;
496 if (TREE_VEC_LENGTH (node) > 0)
497 {
498 size_t len = TREE_VEC_LENGTH (node);
499 for (i = 0; i < len - 1; i++)
500 {
501 dump_generic_node (buffer, TREE_VEC_ELT (node, i), spc, flags,
502 false);
503 pp_character (buffer, ',');
504 pp_space (buffer);
505 }
506 dump_generic_node (buffer, TREE_VEC_ELT (node, len - 1), spc,
507 flags, false);
508 }
509 }
4ee9c684 510 break;
511
4ee9c684 512 case VOID_TYPE:
513 case INTEGER_TYPE:
514 case REAL_TYPE:
06f0b99c 515 case FIXED_POINT_TYPE:
4ee9c684 516 case COMPLEX_TYPE:
517 case VECTOR_TYPE:
518 case ENUMERAL_TYPE:
519 case BOOLEAN_TYPE:
4ee9c684 520 {
521 unsigned int quals = TYPE_QUALS (node);
f4e36c33 522 enum tree_code_class tclass;
4ee9c684 523
524 if (quals & TYPE_QUAL_CONST)
525 pp_string (buffer, "const ");
526 else if (quals & TYPE_QUAL_VOLATILE)
527 pp_string (buffer, "volatile ");
528 else if (quals & TYPE_QUAL_RESTRICT)
529 pp_string (buffer, "restrict ");
530
f4e36c33 531 tclass = TREE_CODE_CLASS (TREE_CODE (node));
4ee9c684 532
f4e36c33 533 if (tclass == tcc_declaration)
4ee9c684 534 {
535 if (DECL_NAME (node))
536 dump_decl_name (buffer, node, flags);
537 else
538 pp_string (buffer, "<unnamed type decl>");
539 }
f4e36c33 540 else if (tclass == tcc_type)
4ee9c684 541 {
542 if (TYPE_NAME (node))
543 {
544 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
545 pp_tree_identifier (buffer, TYPE_NAME (node));
546 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
547 && DECL_NAME (TYPE_NAME (node)))
548 dump_decl_name (buffer, TYPE_NAME (node), flags);
549 else
5d8f2392 550 pp_string (buffer, "<unnamed type>");
551 }
552 else if (TREE_CODE (node) == VECTOR_TYPE)
553 {
554 pp_string (buffer, "vector ");
555 dump_generic_node (buffer, TREE_TYPE (node),
556 spc, flags, false);
4ee9c684 557 }
e4e0b898 558 else if (TREE_CODE (node) == INTEGER_TYPE)
559 {
560 pp_string (buffer, (TYPE_UNSIGNED (node)
561 ? "<unnamed-unsigned:"
562 : "<unnamed-signed:"));
563 pp_decimal_int (buffer, TYPE_PRECISION (node));
564 pp_string (buffer, ">");
565 }
4ee9c684 566 else
567 pp_string (buffer, "<unnamed type>");
568 }
569 break;
570 }
571
572 case POINTER_TYPE:
573 case REFERENCE_TYPE:
574 str = (TREE_CODE (node) == POINTER_TYPE ? "*" : "&");
575
576 if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE)
577 {
578 tree fnode = TREE_TYPE (node);
d700b485 579
4ee9c684 580 dump_generic_node (buffer, TREE_TYPE (fnode), spc, flags, false);
581 pp_space (buffer);
582 pp_character (buffer, '(');
583 pp_string (buffer, str);
584 if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))
585 dump_decl_name (buffer, TYPE_NAME (node), flags);
586 else
587 pp_printf (buffer, "<T%x>", TYPE_UID (node));
588
589 pp_character (buffer, ')');
d700b485 590 dump_function_declaration (buffer, fnode, spc, flags);
4ee9c684 591 }
592 else
593 {
594 unsigned int quals = TYPE_QUALS (node);
595
596 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
597 pp_space (buffer);
598 pp_string (buffer, str);
599
600 if (quals & TYPE_QUAL_CONST)
601 pp_string (buffer, " const");
d3828421 602 if (quals & TYPE_QUAL_VOLATILE)
603 pp_string (buffer, " volatile");
604 if (quals & TYPE_QUAL_RESTRICT)
4ee9c684 605 pp_string (buffer, " restrict");
90cea464 606
607 if (TYPE_REF_CAN_ALIAS_ALL (node))
608 pp_string (buffer, " {ref-all}");
4ee9c684 609 }
610 break;
611
612 case OFFSET_TYPE:
613 NIY;
614 break;
615
616 case METHOD_TYPE:
617 dump_decl_name (buffer, TYPE_NAME (TYPE_METHOD_BASETYPE (node)), flags);
618 pp_string (buffer, "::");
619 break;
620
aed164c3 621 case TARGET_MEM_REF:
622 {
623 const char *sep = "";
624 tree tmp;
625
626 pp_string (buffer, "MEM[");
627
628 tmp = TMR_SYMBOL (node);
629 if (tmp)
630 {
631 pp_string (buffer, sep);
632 sep = ", ";
633 pp_string (buffer, "symbol: ");
634 dump_generic_node (buffer, tmp, spc, flags, false);
635 }
636 tmp = TMR_BASE (node);
637 if (tmp)
638 {
639 pp_string (buffer, sep);
640 sep = ", ";
641 pp_string (buffer, "base: ");
642 dump_generic_node (buffer, tmp, spc, flags, false);
643 }
644 tmp = TMR_INDEX (node);
645 if (tmp)
646 {
647 pp_string (buffer, sep);
648 sep = ", ";
649 pp_string (buffer, "index: ");
650 dump_generic_node (buffer, tmp, spc, flags, false);
651 }
652 tmp = TMR_STEP (node);
653 if (tmp)
654 {
655 pp_string (buffer, sep);
656 sep = ", ";
657 pp_string (buffer, "step: ");
658 dump_generic_node (buffer, tmp, spc, flags, false);
659 }
660 tmp = TMR_OFFSET (node);
661 if (tmp)
662 {
663 pp_string (buffer, sep);
664 sep = ", ";
665 pp_string (buffer, "offset: ");
666 dump_generic_node (buffer, tmp, spc, flags, false);
667 }
668 pp_string (buffer, "]");
669 if (flags & TDF_DETAILS)
670 {
671 pp_string (buffer, "{");
672 dump_generic_node (buffer, TMR_ORIGINAL (node), spc, flags,
673 false);
674 pp_string (buffer, "}");
675 }
676 }
677 break;
678
4ee9c684 679 case ARRAY_TYPE:
680 {
681 tree tmp;
682
a0cac6f5 683 /* Print the innermost component type. */
684 for (tmp = TREE_TYPE (node); TREE_CODE (tmp) == ARRAY_TYPE;
685 tmp = TREE_TYPE (tmp))
686 ;
687 dump_generic_node (buffer, tmp, spc, flags, false);
4ee9c684 688
689 /* Print the dimensions. */
9b1a6180 690 for (tmp = node; TREE_CODE (tmp) == ARRAY_TYPE; tmp = TREE_TYPE (tmp))
691 dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);
4ee9c684 692 break;
693 }
694
4ee9c684 695 case RECORD_TYPE:
696 case UNION_TYPE:
6374121b 697 case QUAL_UNION_TYPE:
d3828421 698 {
699 unsigned int quals = TYPE_QUALS (node);
700
701 if (quals & TYPE_QUAL_CONST)
702 pp_string (buffer, "const ");
703 if (quals & TYPE_QUAL_VOLATILE)
704 pp_string (buffer, "volatile ");
705
706 /* Print the name of the structure. */
707 if (TREE_CODE (node) == RECORD_TYPE)
708 pp_string (buffer, "struct ");
709 else if (TREE_CODE (node) == UNION_TYPE)
710 pp_string (buffer, "union ");
711
712 if (TYPE_NAME (node))
713 dump_generic_node (buffer, TYPE_NAME (node), spc, flags, false);
714 else
715 print_struct_decl (buffer, node, spc, flags);
716 break;
717 }
4ee9c684 718
4ee9c684 719 case LANG_TYPE:
720 NIY;
721 break;
722
723 case INTEGER_CST:
724 if (TREE_CODE (TREE_TYPE (node)) == POINTER_TYPE)
725 {
726 /* In the case of a pointer, one may want to divide by the
727 size of the pointed-to type. Unfortunately, this not
728 straightforward. The C front-end maps expressions
729
730 (int *) 5
731 int *p; (p + 5)
732
733 in such a way that the two INTEGER_CST nodes for "5" have
734 different values but identical types. In the latter
735 case, the 5 is multiplied by sizeof (int) in c-common.c
736 (pointer_int_sum) to convert it to a byte address, and
737 yet the type of the node is left unchanged. Argh. What
738 is consistent though is that the number value corresponds
739 to bytes (UNITS) offset.
740
741 NB: Neither of the following divisors can be trivially
742 used to recover the original literal:
743
744 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
745 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
746 pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
747 pp_string (buffer, "B"); /* pseudo-unit */
748 }
749 else if (! host_integerp (node, 0))
750 {
751 tree val = node;
167a3fa5 752 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (val);
753 HOST_WIDE_INT high = TREE_INT_CST_HIGH (val);
4ee9c684 754
755 if (tree_int_cst_sgn (val) < 0)
756 {
757 pp_character (buffer, '-');
167a3fa5 758 high = ~high + !low;
759 low = -low;
4ee9c684 760 }
761 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
762 systems? */
167a3fa5 763 sprintf (pp_buffer (buffer)->digit_buffer,
7df7561b 764 HOST_WIDE_INT_PRINT_DOUBLE_HEX,
765 (unsigned HOST_WIDE_INT) high, low);
167a3fa5 766 pp_string (buffer, pp_buffer (buffer)->digit_buffer);
4ee9c684 767 }
768 else
769 pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
770 break;
771
772 case REAL_CST:
773 /* Code copied from print_node. */
774 {
775 REAL_VALUE_TYPE d;
776 if (TREE_OVERFLOW (node))
777 pp_string (buffer, " overflow");
778
779#if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC)
780 d = TREE_REAL_CST (node);
781 if (REAL_VALUE_ISINF (d))
3cfd6525 782 pp_string (buffer, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf");
4ee9c684 783 else if (REAL_VALUE_ISNAN (d))
784 pp_string (buffer, " Nan");
785 else
786 {
787 char string[100];
788 real_to_decimal (string, &d, sizeof (string), 0, 1);
789 pp_string (buffer, string);
790 }
791#else
792 {
793 HOST_WIDE_INT i;
794 unsigned char *p = (unsigned char *) &TREE_REAL_CST (node);
795 pp_string (buffer, "0x");
796 for (i = 0; i < sizeof TREE_REAL_CST (node); i++)
797 output_formatted_integer (buffer, "%02x", *p++);
798 }
799#endif
800 break;
801 }
802
06f0b99c 803 case FIXED_CST:
804 {
805 char string[100];
806 fixed_to_decimal (string, TREE_FIXED_CST_PTR (node), sizeof (string));
807 pp_string (buffer, string);
808 break;
809 }
810
4ee9c684 811 case COMPLEX_CST:
812 pp_string (buffer, "__complex__ (");
813 dump_generic_node (buffer, TREE_REALPART (node), spc, flags, false);
814 pp_string (buffer, ", ");
815 dump_generic_node (buffer, TREE_IMAGPART (node), spc, flags, false);
816 pp_string (buffer, ")");
817 break;
818
819 case STRING_CST:
820 pp_string (buffer, "\"");
821 pretty_print_string (buffer, TREE_STRING_POINTER (node));
822 pp_string (buffer, "\"");
823 break;
824
825 case VECTOR_CST:
826 {
827 tree elt;
828 pp_string (buffer, "{ ");
829 for (elt = TREE_VECTOR_CST_ELTS (node); elt; elt = TREE_CHAIN (elt))
830 {
831 dump_generic_node (buffer, TREE_VALUE (elt), spc, flags, false);
832 if (TREE_CHAIN (elt))
833 pp_string (buffer, ", ");
834 }
835 pp_string (buffer, " }");
836 }
837 break;
838
839 case FUNCTION_TYPE:
840 break;
841
842 case FUNCTION_DECL:
843 case CONST_DECL:
844 dump_decl_name (buffer, node, flags);
845 break;
846
847 case LABEL_DECL:
848 if (DECL_NAME (node))
849 dump_decl_name (buffer, node, flags);
850 else if (LABEL_DECL_UID (node) != -1)
b4e7b9fe 851 pp_printf (buffer, "<L%d>", (int) LABEL_DECL_UID (node));
4ee9c684 852 else
90db18cd 853 pp_printf (buffer, "<D.%u>", DECL_UID (node));
4ee9c684 854 break;
855
856 case TYPE_DECL:
7bd3dcc4 857 if (DECL_IS_BUILTIN (node))
4ee9c684 858 {
859 /* Don't print the declaration of built-in types. */
860 break;
861 }
862 if (DECL_NAME (node))
d700b485 863 dump_decl_name (buffer, node, flags);
4ee9c684 864 else
865 {
efa75d92 866 if ((TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
867 || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
868 && TYPE_METHODS (TREE_TYPE (node)))
4ee9c684 869 {
870 /* The type is a c++ class: all structures have at least
0bed3869 871 4 methods. */
4ee9c684 872 pp_string (buffer, "class ");
873 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
874 }
875 else
876 {
d700b485 877 pp_string (buffer,
878 (TREE_CODE (TREE_TYPE (node)) == UNION_TYPE
879 ? "union" : "struct "));
4ee9c684 880 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
4ee9c684 881 }
882 }
883 break;
884
eff665b7 885 case SYMBOL_MEMORY_TAG:
437f5d6b 886 case NAME_MEMORY_TAG:
4ee9c684 887 case VAR_DECL:
888 case PARM_DECL:
889 case FIELD_DECL:
890 case NAMESPACE_DECL:
4fb5e5ca 891 case MEMORY_PARTITION_TAG:
4ee9c684 892 dump_decl_name (buffer, node, flags);
893 break;
894
895 case RESULT_DECL:
896 pp_string (buffer, "<retval>");
897 break;
898
899 case COMPONENT_REF:
900 op0 = TREE_OPERAND (node, 0);
901 str = ".";
902 if (TREE_CODE (op0) == INDIRECT_REF)
903 {
904 op0 = TREE_OPERAND (op0, 0);
905 str = "->";
906 }
907 if (op_prio (op0) < op_prio (node))
908 pp_character (buffer, '(');
909 dump_generic_node (buffer, op0, spc, flags, false);
910 if (op_prio (op0) < op_prio (node))
911 pp_character (buffer, ')');
912 pp_string (buffer, str);
913 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
f6c33c78 914 op0 = component_ref_field_offset (node);
915 if (op0 && TREE_CODE (op0) != INTEGER_CST)
6374121b 916 {
f6c33c78 917 pp_string (buffer, "{off: ");
e3349ccb 918 dump_generic_node (buffer, op0, spc, flags, false);
919 pp_character (buffer, '}');
6374121b 920 }
4ee9c684 921 break;
922
923 case BIT_FIELD_REF:
924 pp_string (buffer, "BIT_FIELD_REF <");
925 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
926 pp_string (buffer, ", ");
927 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
928 pp_string (buffer, ", ");
929 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
930 pp_string (buffer, ">");
931 break;
932
4ee9c684 933 case ARRAY_REF:
6374121b 934 case ARRAY_RANGE_REF:
4ee9c684 935 op0 = TREE_OPERAND (node, 0);
936 if (op_prio (op0) < op_prio (node))
937 pp_character (buffer, '(');
938 dump_generic_node (buffer, op0, spc, flags, false);
939 if (op_prio (op0) < op_prio (node))
940 pp_character (buffer, ')');
941 pp_character (buffer, '[');
942 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
6374121b 943 if (TREE_CODE (node) == ARRAY_RANGE_REF)
944 pp_string (buffer, " ...");
4ee9c684 945 pp_character (buffer, ']');
4ee9c684 946
1267d2b7 947 op0 = array_ref_low_bound (node);
948 op1 = array_ref_element_size (node);
949
950 if (!integer_zerop (op0)
a128a28f 951 || TREE_OPERAND (node, 2)
952 || TREE_OPERAND (node, 3))
6374121b 953 {
954 pp_string (buffer, "{lb: ");
1267d2b7 955 dump_generic_node (buffer, op0, spc, flags, false);
6374121b 956 pp_string (buffer, " sz: ");
1267d2b7 957 dump_generic_node (buffer, op1, spc, flags, false);
6374121b 958 pp_character (buffer, '}');
959 }
4ee9c684 960 break;
961
962 case CONSTRUCTOR:
963 {
c75b4594 964 unsigned HOST_WIDE_INT ix;
965 tree field, val;
4ee9c684 966 bool is_struct_init = FALSE;
967 pp_character (buffer, '{');
4ee9c684 968 if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
969 || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
970 is_struct_init = TRUE;
c75b4594 971 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), ix, field, val)
4ee9c684 972 {
c75b4594 973 if (field && is_struct_init)
4ee9c684 974 {
975 pp_character (buffer, '.');
c75b4594 976 dump_generic_node (buffer, field, spc, flags, false);
4ee9c684 977 pp_string (buffer, "=");
978 }
4ee9c684 979 if (val && TREE_CODE (val) == ADDR_EXPR)
980 if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL)
981 val = TREE_OPERAND (val, 0);
982 if (val && TREE_CODE (val) == FUNCTION_DECL)
4ee9c684 983 dump_decl_name (buffer, val, flags);
4ee9c684 984 else
c75b4594 985 dump_generic_node (buffer, val, spc, flags, false);
986 if (ix != VEC_length (constructor_elt, CONSTRUCTOR_ELTS (node)) - 1)
4ee9c684 987 {
988 pp_character (buffer, ',');
989 pp_space (buffer);
990 }
991 }
992 pp_character (buffer, '}');
993 }
994 break;
995
996 case COMPOUND_EXPR:
997 {
998 tree *tp;
999 if (flags & TDF_SLIM)
1000 {
1001 pp_string (buffer, "<COMPOUND_EXPR>");
1002 break;
1003 }
1004
1005 dump_generic_node (buffer, TREE_OPERAND (node, 0),
1e8e9920 1006 spc, flags, !(flags & TDF_SLIM));
1007 if (flags & TDF_SLIM)
4ee9c684 1008 newline_and_indent (buffer, spc);
1009 else
1010 {
1011 pp_character (buffer, ',');
1012 pp_space (buffer);
1013 }
1014
1015 for (tp = &TREE_OPERAND (node, 1);
1016 TREE_CODE (*tp) == COMPOUND_EXPR;
1017 tp = &TREE_OPERAND (*tp, 1))
1018 {
1019 dump_generic_node (buffer, TREE_OPERAND (*tp, 0),
1e8e9920 1020 spc, flags, !(flags & TDF_SLIM));
1021 if (flags & TDF_SLIM)
4ee9c684 1022 newline_and_indent (buffer, spc);
1023 else
1024 {
1025 pp_character (buffer, ',');
1026 pp_space (buffer);
1027 }
1028 }
1029
1e8e9920 1030 dump_generic_node (buffer, *tp, spc, flags, !(flags & TDF_SLIM));
4ee9c684 1031 }
1032 break;
1033
1034 case STATEMENT_LIST:
1035 {
1036 tree_stmt_iterator si;
1037 bool first = true;
b27ac6b5 1038
1e8e9920 1039 if (flags & TDF_SLIM)
4ee9c684 1040 {
1041 pp_string (buffer, "<STATEMENT_LIST>");
1042 break;
1043 }
1044
1045 for (si = tsi_start (node); !tsi_end_p (si); tsi_next (&si))
1046 {
1047 if (!first)
1048 newline_and_indent (buffer, spc);
1049 else
1050 first = false;
1051 dump_generic_node (buffer, tsi_stmt (si), spc, flags, true);
1052 }
1053 }
1054 break;
1055
1056 case MODIFY_EXPR:
1057 case INIT_EXPR:
75a70cf9 1058 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags,
35cc02b5 1059 false);
4ee9c684 1060 pp_space (buffer);
1061 pp_character (buffer, '=');
75a70cf9 1062 if (TREE_CODE (node) == MODIFY_EXPR
5b5037b3 1063 && MOVE_NONTEMPORAL (node))
1064 pp_string (buffer, "{nt}");
4ee9c684 1065 pp_space (buffer);
75a70cf9 1066 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags,
35cc02b5 1067 false);
4ee9c684 1068 break;
1069
1070 case TARGET_EXPR:
2363ef00 1071 pp_string (buffer, "TARGET_EXPR <");
1072 dump_generic_node (buffer, TARGET_EXPR_SLOT (node), spc, flags, false);
1073 pp_character (buffer, ',');
1074 pp_space (buffer);
4ee9c684 1075 dump_generic_node (buffer, TARGET_EXPR_INITIAL (node), spc, flags, false);
2363ef00 1076 pp_character (buffer, '>');
4ee9c684 1077 break;
1078
d700b485 1079 case DECL_EXPR:
1080 print_declaration (buffer, DECL_EXPR_DECL (node), spc, flags);
1081 is_stmt = false;
1082 break;
1083
4ee9c684 1084 case COND_EXPR:
0375a275 1085 if (TREE_TYPE (node) == NULL || TREE_TYPE (node) == void_type_node)
4ee9c684 1086 {
1087 pp_string (buffer, "if (");
1088 dump_generic_node (buffer, COND_EXPR_COND (node), spc, flags, false);
1089 pp_character (buffer, ')');
1090 /* The lowered cond_exprs should always be printed in full. */
1091 if (COND_EXPR_THEN (node)
49377e21 1092 && (IS_EMPTY_STMT (COND_EXPR_THEN (node))
1093 || TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR)
4ee9c684 1094 && COND_EXPR_ELSE (node)
49377e21 1095 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node))
1096 || TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR))
4ee9c684 1097 {
1098 pp_space (buffer);
24f116a8 1099 dump_generic_node (buffer, COND_EXPR_THEN (node),
1100 0, flags, true);
1101 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
1102 {
1103 pp_string (buffer, " else ");
1104 dump_generic_node (buffer, COND_EXPR_ELSE (node),
1105 0, flags, true);
1106 }
4ee9c684 1107 }
1108 else if (!(flags & TDF_SLIM))
1109 {
1110 /* Output COND_EXPR_THEN. */
1111 if (COND_EXPR_THEN (node))
1112 {
1113 newline_and_indent (buffer, spc+2);
1114 pp_character (buffer, '{');
1115 newline_and_indent (buffer, spc+4);
1116 dump_generic_node (buffer, COND_EXPR_THEN (node), spc+4,
1117 flags, true);
1118 newline_and_indent (buffer, spc+2);
1119 pp_character (buffer, '}');
1120 }
1121
1122 /* Output COND_EXPR_ELSE. */
24f116a8 1123 if (COND_EXPR_ELSE (node)
1124 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
4ee9c684 1125 {
1126 newline_and_indent (buffer, spc);
1127 pp_string (buffer, "else");
1128 newline_and_indent (buffer, spc+2);
1129 pp_character (buffer, '{');
1130 newline_and_indent (buffer, spc+4);
1131 dump_generic_node (buffer, COND_EXPR_ELSE (node), spc+4,
1132 flags, true);
1133 newline_and_indent (buffer, spc+2);
1134 pp_character (buffer, '}');
1135 }
1136 }
1137 is_expr = false;
1138 }
1139 else
1140 {
1141 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1142 pp_space (buffer);
1143 pp_character (buffer, '?');
1144 pp_space (buffer);
1145 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1146 pp_space (buffer);
1147 pp_character (buffer, ':');
1148 pp_space (buffer);
1149 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1150 }
1151 break;
1152
1153 case BIND_EXPR:
1154 pp_character (buffer, '{');
1155 if (!(flags & TDF_SLIM))
1156 {
1157 if (BIND_EXPR_VARS (node))
1158 {
1159 pp_newline (buffer);
1160
1161 for (op0 = BIND_EXPR_VARS (node); op0; op0 = TREE_CHAIN (op0))
1162 {
1163 print_declaration (buffer, op0, spc+2, flags);
1164 pp_newline (buffer);
1165 }
1166 }
1167
1168 newline_and_indent (buffer, spc+2);
1169 dump_generic_node (buffer, BIND_EXPR_BODY (node), spc+2, flags, true);
1170 newline_and_indent (buffer, spc);
1171 pp_character (buffer, '}');
1172 }
1173 is_expr = false;
1174 break;
1175
1176 case CALL_EXPR:
1177 print_call_name (buffer, node);
1178
1179 /* Print parameters. */
1180 pp_space (buffer);
1181 pp_character (buffer, '(');
c2f47e15 1182 {
1183 tree arg;
1184 call_expr_arg_iterator iter;
1185 FOR_EACH_CALL_EXPR_ARG (arg, iter, node)
1186 {
1187 dump_generic_node (buffer, arg, spc, flags, false);
1188 if (more_call_expr_args_p (&iter))
1189 {
1190 pp_character (buffer, ',');
1191 pp_space (buffer);
1192 }
1193 }
1194 }
48dc2227 1195 if (CALL_EXPR_VA_ARG_PACK (node))
1196 {
1197 if (call_expr_nargs (node) > 0)
1198 {
1199 pp_character (buffer, ',');
1200 pp_space (buffer);
1201 }
1202 pp_string (buffer, "__builtin_va_arg_pack ()");
1203 }
4ee9c684 1204 pp_character (buffer, ')');
1205
c2f47e15 1206 op1 = CALL_EXPR_STATIC_CHAIN (node);
4ee9c684 1207 if (op1)
1208 {
1209 pp_string (buffer, " [static-chain: ");
1210 dump_generic_node (buffer, op1, spc, flags, false);
1211 pp_character (buffer, ']');
1212 }
1213
ea523851 1214 if (CALL_EXPR_RETURN_SLOT_OPT (node))
1215 pp_string (buffer, " [return slot optimization]");
4ee9c684 1216 if (CALL_EXPR_TAILCALL (node))
1217 pp_string (buffer, " [tail call]");
1218 break;
1219
1220 case WITH_CLEANUP_EXPR:
1221 NIY;
1222 break;
1223
1224 case CLEANUP_POINT_EXPR:
1225 pp_string (buffer, "<<cleanup_point ");
1226 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1227 pp_string (buffer, ">>");
1228 break;
1229
1230 case PLACEHOLDER_EXPR:
d700b485 1231 pp_string (buffer, "<PLACEHOLDER_EXPR ");
1232 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1233 pp_character (buffer, '>');
4ee9c684 1234 break;
1235
1236 /* Binary arithmetic and logic expressions. */
4a61a337 1237 case WIDEN_SUM_EXPR:
1238 case WIDEN_MULT_EXPR:
4ee9c684 1239 case MULT_EXPR:
1240 case PLUS_EXPR:
0de36bdb 1241 case POINTER_PLUS_EXPR:
4ee9c684 1242 case MINUS_EXPR:
1243 case TRUNC_DIV_EXPR:
1244 case CEIL_DIV_EXPR:
1245 case FLOOR_DIV_EXPR:
1246 case ROUND_DIV_EXPR:
1247 case TRUNC_MOD_EXPR:
1248 case CEIL_MOD_EXPR:
1249 case FLOOR_MOD_EXPR:
1250 case ROUND_MOD_EXPR:
1251 case RDIV_EXPR:
1252 case EXACT_DIV_EXPR:
1253 case LSHIFT_EXPR:
1254 case RSHIFT_EXPR:
1255 case LROTATE_EXPR:
1256 case RROTATE_EXPR:
925c62d4 1257 case VEC_LSHIFT_EXPR:
1258 case VEC_RSHIFT_EXPR:
4ee9c684 1259 case BIT_IOR_EXPR:
1260 case BIT_XOR_EXPR:
1261 case BIT_AND_EXPR:
1262 case TRUTH_ANDIF_EXPR:
1263 case TRUTH_ORIF_EXPR:
1264 case TRUTH_AND_EXPR:
1265 case TRUTH_OR_EXPR:
1266 case TRUTH_XOR_EXPR:
1267 case LT_EXPR:
1268 case LE_EXPR:
1269 case GT_EXPR:
1270 case GE_EXPR:
1271 case EQ_EXPR:
1272 case NE_EXPR:
1273 case UNLT_EXPR:
1274 case UNLE_EXPR:
1275 case UNGT_EXPR:
1276 case UNGE_EXPR:
1277 case UNEQ_EXPR:
318a728f 1278 case LTGT_EXPR:
1279 case ORDERED_EXPR:
1280 case UNORDERED_EXPR:
4ee9c684 1281 {
1282 const char *op = op_symbol (node);
1283 op0 = TREE_OPERAND (node, 0);
1284 op1 = TREE_OPERAND (node, 1);
1285
1286 /* When the operands are expressions with less priority,
1287 keep semantics of the tree representation. */
3814cd68 1288 if (op_prio (op0) <= op_prio (node))
4ee9c684 1289 {
1290 pp_character (buffer, '(');
1291 dump_generic_node (buffer, op0, spc, flags, false);
1292 pp_character (buffer, ')');
1293 }
1294 else
1295 dump_generic_node (buffer, op0, spc, flags, false);
1296
1297 pp_space (buffer);
1298 pp_string (buffer, op);
1299 pp_space (buffer);
1300
1301 /* When the operands are expressions with less priority,
1302 keep semantics of the tree representation. */
3814cd68 1303 if (op_prio (op1) <= op_prio (node))
4ee9c684 1304 {
1305 pp_character (buffer, '(');
1306 dump_generic_node (buffer, op1, spc, flags, false);
1307 pp_character (buffer, ')');
1308 }
1309 else
1310 dump_generic_node (buffer, op1, spc, flags, false);
1311 }
1312 break;
1313
1314 /* Unary arithmetic and logic expressions. */
1315 case NEGATE_EXPR:
1316 case BIT_NOT_EXPR:
1317 case TRUTH_NOT_EXPR:
1318 case ADDR_EXPR:
4ee9c684 1319 case PREDECREMENT_EXPR:
1320 case PREINCREMENT_EXPR:
b056d812 1321 case ALIGN_INDIRECT_REF:
1322 case MISALIGNED_INDIRECT_REF:
4ee9c684 1323 case INDIRECT_REF:
1324 if (TREE_CODE (node) == ADDR_EXPR
1325 && (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST
1326 || TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL))
1327 ; /* Do not output '&' for strings and function pointers. */
1328 else
1329 pp_string (buffer, op_symbol (node));
1330
1331 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
1332 {
1333 pp_character (buffer, '(');
1334 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1335 pp_character (buffer, ')');
1336 }
1337 else
1338 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
b056d812 1339
1340 if (TREE_CODE (node) == MISALIGNED_INDIRECT_REF)
1341 {
1342 pp_string (buffer, "{misalignment: ");
1343 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1344 pp_character (buffer, '}');
1345 }
4ee9c684 1346 break;
1347
1348 case POSTDECREMENT_EXPR:
1349 case POSTINCREMENT_EXPR:
1350 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
1351 {
1352 pp_character (buffer, '(');
1353 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1354 pp_character (buffer, ')');
1355 }
1356 else
1357 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1358 pp_string (buffer, op_symbol (node));
1359 break;
1360
1361 case MIN_EXPR:
1362 pp_string (buffer, "MIN_EXPR <");
1363 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1364 pp_string (buffer, ", ");
1365 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1366 pp_character (buffer, '>');
1367 break;
1368
1369 case MAX_EXPR:
1370 pp_string (buffer, "MAX_EXPR <");
1371 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1372 pp_string (buffer, ", ");
1373 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1374 pp_character (buffer, '>');
1375 break;
1376
1377 case ABS_EXPR:
1378 pp_string (buffer, "ABS_EXPR <");
1379 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1380 pp_character (buffer, '>');
1381 break;
1382
4ee9c684 1383 case RANGE_EXPR:
1384 NIY;
1385 break;
1386
06f0b99c 1387 case FIXED_CONVERT_EXPR:
4ee9c684 1388 case FIX_TRUNC_EXPR:
4ee9c684 1389 case FLOAT_EXPR:
72dd6141 1390 CASE_CONVERT:
4ee9c684 1391 type = TREE_TYPE (node);
1392 op0 = TREE_OPERAND (node, 0);
1393 if (type != TREE_TYPE (op0))
1394 {
1395 pp_character (buffer, '(');
1396 dump_generic_node (buffer, type, spc, flags, false);
153536df 1397 pp_string (buffer, ") ");
4ee9c684 1398 }
1399 if (op_prio (op0) < op_prio (node))
1400 pp_character (buffer, '(');
1401 dump_generic_node (buffer, op0, spc, flags, false);
1402 if (op_prio (op0) < op_prio (node))
1403 pp_character (buffer, ')');
1404 break;
1405
1406 case VIEW_CONVERT_EXPR:
1407 pp_string (buffer, "VIEW_CONVERT_EXPR<");
1408 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1409 pp_string (buffer, ">(");
1410 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1411 pp_character (buffer, ')');
1412 break;
1413
751ff693 1414 case PAREN_EXPR:
1415 pp_string (buffer, "((");
1416 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1417 pp_string (buffer, "))");
1418 break;
1419
4ee9c684 1420 case NON_LVALUE_EXPR:
1421 pp_string (buffer, "NON_LVALUE_EXPR <");
1422 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1423 pp_character (buffer, '>');
1424 break;
1425
1426 case SAVE_EXPR:
1427 pp_string (buffer, "SAVE_EXPR <");
1428 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1429 pp_character (buffer, '>');
1430 break;
1431
4ee9c684 1432 case COMPLEX_EXPR:
1433 pp_string (buffer, "COMPLEX_EXPR <");
1434 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1435 pp_string (buffer, ", ");
1436 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1437 pp_string (buffer, ">");
1438 break;
1439
1440 case CONJ_EXPR:
1441 pp_string (buffer, "CONJ_EXPR <");
1442 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1443 pp_string (buffer, ">");
1444 break;
1445
1446 case REALPART_EXPR:
1447 pp_string (buffer, "REALPART_EXPR <");
1448 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1449 pp_string (buffer, ">");
1450 break;
1451
1452 case IMAGPART_EXPR:
1453 pp_string (buffer, "IMAGPART_EXPR <");
1454 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1455 pp_string (buffer, ">");
1456 break;
1457
1458 case VA_ARG_EXPR:
1459 pp_string (buffer, "VA_ARG_EXPR <");
1460 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1461 pp_string (buffer, ">");
1462 break;
1463
1464 case TRY_FINALLY_EXPR:
1465 case TRY_CATCH_EXPR:
1466 pp_string (buffer, "try");
1467 newline_and_indent (buffer, spc+2);
1468 pp_string (buffer, "{");
1469 newline_and_indent (buffer, spc+4);
1470 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc+4, flags, true);
1471 newline_and_indent (buffer, spc+2);
1472 pp_string (buffer, "}");
1473 newline_and_indent (buffer, spc);
1474 pp_string (buffer,
1475 (TREE_CODE (node) == TRY_CATCH_EXPR) ? "catch" : "finally");
1476 newline_and_indent (buffer, spc+2);
1477 pp_string (buffer, "{");
1478 newline_and_indent (buffer, spc+4);
1479 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc+4, flags, true);
1480 newline_and_indent (buffer, spc+2);
1481 pp_string (buffer, "}");
1482 is_expr = false;
1483 break;
1484
1485 case CATCH_EXPR:
1486 pp_string (buffer, "catch (");
1487 dump_generic_node (buffer, CATCH_TYPES (node), spc+2, flags, false);
1488 pp_string (buffer, ")");
1489 newline_and_indent (buffer, spc+2);
1490 pp_string (buffer, "{");
1491 newline_and_indent (buffer, spc+4);
1492 dump_generic_node (buffer, CATCH_BODY (node), spc+4, flags, true);
1493 newline_and_indent (buffer, spc+2);
1494 pp_string (buffer, "}");
1495 is_expr = false;
1496 break;
1497
1498 case EH_FILTER_EXPR:
1499 pp_string (buffer, "<<<eh_filter (");
1500 dump_generic_node (buffer, EH_FILTER_TYPES (node), spc+2, flags, false);
1501 pp_string (buffer, ")>>>");
1502 newline_and_indent (buffer, spc+2);
1503 pp_string (buffer, "{");
1504 newline_and_indent (buffer, spc+4);
1505 dump_generic_node (buffer, EH_FILTER_FAILURE (node), spc+4, flags, true);
1506 newline_and_indent (buffer, spc+2);
1507 pp_string (buffer, "}");
1508 is_expr = false;
1509 break;
1510
66723563 1511 case CHANGE_DYNAMIC_TYPE_EXPR:
1512 pp_string (buffer, "<<<change_dynamic_type (");
1513 dump_generic_node (buffer, CHANGE_DYNAMIC_TYPE_NEW_TYPE (node), spc + 2,
1514 flags, false);
1515 pp_string (buffer, ") ");
1516 dump_generic_node (buffer, CHANGE_DYNAMIC_TYPE_LOCATION (node), spc + 2,
1517 flags, false);
1518 pp_string (buffer, ")>>>");
1519 is_expr = false;
1520 break;
1521
4ee9c684 1522 case LABEL_EXPR:
1523 op0 = TREE_OPERAND (node, 0);
1524 /* If this is for break or continue, don't bother printing it. */
1525 if (DECL_NAME (op0))
1526 {
1527 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1528 if (strcmp (name, "break") == 0
1529 || strcmp (name, "continue") == 0)
1530 break;
1531 }
1532 dump_generic_node (buffer, op0, spc, flags, false);
1533 pp_character (buffer, ':');
1534 if (DECL_NONLOCAL (op0))
1535 pp_string (buffer, " [non-local]");
1536 break;
1537
4ee9c684 1538 case EXC_PTR_EXPR:
1539 pp_string (buffer, "<<<exception object>>>");
1540 break;
1541
1542 case FILTER_EXPR:
1543 pp_string (buffer, "<<<filter object>>>");
1544 break;
1545
1546 case LOOP_EXPR:
1547 pp_string (buffer, "while (1)");
1548 if (!(flags & TDF_SLIM))
1549 {
1550 newline_and_indent (buffer, spc+2);
1551 pp_character (buffer, '{');
1552 newline_and_indent (buffer, spc+4);
1553 dump_generic_node (buffer, LOOP_EXPR_BODY (node), spc+4, flags, true);
1554 newline_and_indent (buffer, spc+2);
1555 pp_character (buffer, '}');
1556 }
1557 is_expr = false;
1558 break;
1559
4a1849e3 1560 case PREDICT_EXPR:
1561 pp_string (buffer, "// predicted ");
1562 if (PREDICT_EXPR_OUTCOME (node))
1563 pp_string (buffer, "likely by ");
1564 else
1565 pp_string (buffer, "unlikely by ");
1566 pp_string (buffer, predictor_name (PREDICT_EXPR_PREDICTOR (node)));
1567 pp_string (buffer, " predictor.");
1568 break;
1569
4ee9c684 1570 case RETURN_EXPR:
1571 pp_string (buffer, "return");
1572 op0 = TREE_OPERAND (node, 0);
1573 if (op0)
1574 {
1575 pp_space (buffer);
75a70cf9 1576 if (TREE_CODE (op0) == MODIFY_EXPR)
1577 dump_generic_node (buffer, TREE_OPERAND (op0, 1),
35cc02b5 1578 spc, flags, false);
4ee9c684 1579 else
1580 dump_generic_node (buffer, op0, spc, flags, false);
1581 }
1582 break;
1583
1584 case EXIT_EXPR:
1585 pp_string (buffer, "if (");
1586 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1587 pp_string (buffer, ") break");
1588 break;
1589
1590 case SWITCH_EXPR:
1591 pp_string (buffer, "switch (");
1592 dump_generic_node (buffer, SWITCH_COND (node), spc, flags, false);
1593 pp_character (buffer, ')');
1594 if (!(flags & TDF_SLIM))
1595 {
1596 newline_and_indent (buffer, spc+2);
1597 pp_character (buffer, '{');
1598 if (SWITCH_BODY (node))
1599 {
1600 newline_and_indent (buffer, spc+4);
1e8e9920 1601 dump_generic_node (buffer, SWITCH_BODY (node), spc+4, flags,
1602 true);
4ee9c684 1603 }
1604 else
1605 {
1606 tree vec = SWITCH_LABELS (node);
1607 size_t i, n = TREE_VEC_LENGTH (vec);
1608 for (i = 0; i < n; ++i)
1609 {
1610 tree elt = TREE_VEC_ELT (vec, i);
1611 newline_and_indent (buffer, spc+4);
1e8e9920 1612 if (elt)
1613 {
1614 dump_generic_node (buffer, elt, spc+4, flags, false);
1615 pp_string (buffer, " goto ");
1616 dump_generic_node (buffer, CASE_LABEL (elt), spc+4,
1617 flags, true);
1618 pp_semicolon (buffer);
1619 }
1620 else
1621 pp_string (buffer, "case ???: goto ???;");
4ee9c684 1622 }
1623 }
1624 newline_and_indent (buffer, spc+2);
1625 pp_character (buffer, '}');
1626 }
1627 is_expr = false;
1628 break;
1629
1630 case GOTO_EXPR:
1631 op0 = GOTO_DESTINATION (node);
ce45a448 1632 if (TREE_CODE (op0) != SSA_NAME && DECL_P (op0) && DECL_NAME (op0))
4ee9c684 1633 {
1634 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1635 if (strcmp (name, "break") == 0
1636 || strcmp (name, "continue") == 0)
1637 {
1638 pp_string (buffer, name);
1639 break;
1640 }
1641 }
1642 pp_string (buffer, "goto ");
1643 dump_generic_node (buffer, op0, spc, flags, false);
1644 break;
1645
1646 case RESX_EXPR:
30b822ea 1647 pp_string (buffer, "resx ");
1648 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
4ee9c684 1649 break;
1650
1651 case ASM_EXPR:
1652 pp_string (buffer, "__asm__");
1653 if (ASM_VOLATILE_P (node))
1654 pp_string (buffer, " __volatile__");
1655 pp_character (buffer, '(');
1656 dump_generic_node (buffer, ASM_STRING (node), spc, flags, false);
1657 pp_character (buffer, ':');
1658 dump_generic_node (buffer, ASM_OUTPUTS (node), spc, flags, false);
1659 pp_character (buffer, ':');
1660 dump_generic_node (buffer, ASM_INPUTS (node), spc, flags, false);
1661 if (ASM_CLOBBERS (node))
1662 {
1663 pp_character (buffer, ':');
1664 dump_generic_node (buffer, ASM_CLOBBERS (node), spc, flags, false);
1665 }
1666 pp_string (buffer, ")");
1667 break;
1668
1669 case CASE_LABEL_EXPR:
1670 if (CASE_LOW (node) && CASE_HIGH (node))
1671 {
1672 pp_string (buffer, "case ");
1673 dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
1674 pp_string (buffer, " ... ");
1675 dump_generic_node (buffer, CASE_HIGH (node), spc, flags, false);
1676 }
1677 else if (CASE_LOW (node))
1678 {
1679 pp_string (buffer, "case ");
1680 dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
1681 }
1682 else
75a70cf9 1683 pp_string (buffer, "default");
4ee9c684 1684 pp_character (buffer, ':');
1685 break;
1686
215e2f1d 1687 case OBJ_TYPE_REF:
1688 pp_string (buffer, "OBJ_TYPE_REF(");
1689 dump_generic_node (buffer, OBJ_TYPE_REF_EXPR (node), spc, flags, false);
1690 pp_character (buffer, ';');
1691 dump_generic_node (buffer, OBJ_TYPE_REF_OBJECT (node), spc, flags, false);
1692 pp_character (buffer, '-');
4ee9c684 1693 pp_character (buffer, '>');
215e2f1d 1694 dump_generic_node (buffer, OBJ_TYPE_REF_TOKEN (node), spc, flags, false);
1695 pp_character (buffer, ')');
4ee9c684 1696 break;
1697
4ee9c684 1698 case SSA_NAME:
1699 dump_generic_node (buffer, SSA_NAME_VAR (node), spc, flags, false);
1700 pp_string (buffer, "_");
1701 pp_decimal_int (buffer, SSA_NAME_VERSION (node));
2b6719e9 1702 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))
1703 pp_string (buffer, "(ab)");
4fb5e5ca 1704 else if (SSA_NAME_IS_DEFAULT_DEF (node))
1705 pp_string (buffer, "(D)");
4ee9c684 1706 break;
1707
80f06481 1708 case WITH_SIZE_EXPR:
1709 pp_string (buffer, "WITH_SIZE_EXPR <");
1710 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1711 pp_string (buffer, ", ");
1712 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1713 pp_string (buffer, ">");
1714 break;
1715
88dbf20f 1716 case ASSERT_EXPR:
1717 pp_string (buffer, "ASSERT_EXPR <");
1718 dump_generic_node (buffer, ASSERT_EXPR_VAR (node), spc, flags, false);
1719 pp_string (buffer, ", ");
1720 dump_generic_node (buffer, ASSERT_EXPR_COND (node), spc, flags, false);
1721 pp_string (buffer, ">");
1722 break;
1723
101d9422 1724 case SCEV_KNOWN:
1725 pp_string (buffer, "scev_known");
1726 break;
1727
1728 case SCEV_NOT_KNOWN:
1729 pp_string (buffer, "scev_not_known");
1730 break;
1731
1732 case POLYNOMIAL_CHREC:
1733 pp_string (buffer, "{");
1734 dump_generic_node (buffer, CHREC_LEFT (node), spc, flags, false);
1735 pp_string (buffer, ", +, ");
1736 dump_generic_node (buffer, CHREC_RIGHT (node), spc, flags, false);
1737 pp_string (buffer, "}_");
1738 dump_generic_node (buffer, CHREC_VAR (node), spc, flags, false);
1739 is_stmt = false;
1740 break;
1741
b056d812 1742 case REALIGN_LOAD_EXPR:
1743 pp_string (buffer, "REALIGN_LOAD <");
1744 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1745 pp_string (buffer, ", ");
1746 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1747 pp_string (buffer, ", ");
1748 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1749 pp_string (buffer, ">");
1750 break;
1751
5c4f2f32 1752 case VEC_COND_EXPR:
1753 pp_string (buffer, " VEC_COND_EXPR < ");
1754 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1755 pp_string (buffer, " , ");
1756 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1757 pp_string (buffer, " , ");
1758 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1759 pp_string (buffer, " > ");
1760 break;
1761
4a61a337 1762 case DOT_PROD_EXPR:
1763 pp_string (buffer, " DOT_PROD_EXPR < ");
1764 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
c6c91d61 1765 pp_string (buffer, ", ");
4a61a337 1766 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
c6c91d61 1767 pp_string (buffer, ", ");
4a61a337 1768 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1769 pp_string (buffer, " > ");
1770 break;
1771
1e8e9920 1772 case OMP_PARALLEL:
1773 pp_string (buffer, "#pragma omp parallel");
1774 dump_omp_clauses (buffer, OMP_PARALLEL_CLAUSES (node), spc, flags);
1775
1776 dump_omp_body:
1777 if (!(flags & TDF_SLIM) && OMP_BODY (node))
1778 {
1779 newline_and_indent (buffer, spc + 2);
1780 pp_character (buffer, '{');
1781 newline_and_indent (buffer, spc + 4);
1782 dump_generic_node (buffer, OMP_BODY (node), spc + 4, flags, false);
1783 newline_and_indent (buffer, spc + 2);
1784 pp_character (buffer, '}');
1785 }
1786 is_expr = false;
1787 break;
1788
fd6481cf 1789 case OMP_TASK:
1790 pp_string (buffer, "#pragma omp task");
1791 dump_omp_clauses (buffer, OMP_TASK_CLAUSES (node), spc, flags);
fd6481cf 1792 goto dump_omp_body;
1793
1e8e9920 1794 case OMP_FOR:
1795 pp_string (buffer, "#pragma omp for");
1796 dump_omp_clauses (buffer, OMP_FOR_CLAUSES (node), spc, flags);
1797
1798 if (!(flags & TDF_SLIM))
1799 {
fd6481cf 1800 int i;
1801
1e8e9920 1802 if (OMP_FOR_PRE_BODY (node))
1803 {
1804 newline_and_indent (buffer, spc + 2);
1805 pp_character (buffer, '{');
1806 spc += 4;
1807 newline_and_indent (buffer, spc);
1808 dump_generic_node (buffer, OMP_FOR_PRE_BODY (node),
1809 spc, flags, false);
1810 }
fd6481cf 1811 spc -= 2;
1812 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (node)); i++)
1813 {
1814 spc += 2;
1815 newline_and_indent (buffer, spc);
1816 pp_string (buffer, "for (");
1817 dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_INIT (node), i),
1818 spc, flags, false);
1819 pp_string (buffer, "; ");
1820 dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_COND (node), i),
1821 spc, flags, false);
1822 pp_string (buffer, "; ");
1823 dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_INCR (node), i),
1824 spc, flags, false);
1825 pp_string (buffer, ")");
1826 }
1e8e9920 1827 if (OMP_FOR_BODY (node))
1828 {
1829 newline_and_indent (buffer, spc + 2);
1830 pp_character (buffer, '{');
1831 newline_and_indent (buffer, spc + 4);
1832 dump_generic_node (buffer, OMP_FOR_BODY (node), spc + 4, flags,
1833 false);
1834 newline_and_indent (buffer, spc + 2);
1835 pp_character (buffer, '}');
1836 }
fd6481cf 1837 spc -= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node)) - 2;
1e8e9920 1838 if (OMP_FOR_PRE_BODY (node))
1839 {
1840 spc -= 4;
1841 newline_and_indent (buffer, spc + 2);
1842 pp_character (buffer, '}');
1843 }
1844 }
1845 is_expr = false;
1846 break;
1847
1848 case OMP_SECTIONS:
1849 pp_string (buffer, "#pragma omp sections");
1850 dump_omp_clauses (buffer, OMP_SECTIONS_CLAUSES (node), spc, flags);
1851 goto dump_omp_body;
1852
1853 case OMP_SECTION:
1854 pp_string (buffer, "#pragma omp section");
1855 goto dump_omp_body;
1856
1857 case OMP_MASTER:
1858 pp_string (buffer, "#pragma omp master");
1859 goto dump_omp_body;
1860
1861 case OMP_ORDERED:
1862 pp_string (buffer, "#pragma omp ordered");
1863 goto dump_omp_body;
1864
1865 case OMP_CRITICAL:
1866 pp_string (buffer, "#pragma omp critical");
1867 if (OMP_CRITICAL_NAME (node))
1868 {
1869 pp_space (buffer);
1870 pp_character (buffer, '(');
1871 dump_generic_node (buffer, OMP_CRITICAL_NAME (node), spc,
1872 flags, false);
1873 pp_character (buffer, ')');
1874 }
1875 goto dump_omp_body;
1876
1877 case OMP_ATOMIC:
1878 pp_string (buffer, "#pragma omp atomic");
1879 newline_and_indent (buffer, spc + 2);
1880 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1881 pp_space (buffer);
1882 pp_character (buffer, '=');
1883 pp_space (buffer);
1884 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1885 break;
1886
1887 case OMP_SINGLE:
1888 pp_string (buffer, "#pragma omp single");
1889 dump_omp_clauses (buffer, OMP_SINGLE_CLAUSES (node), spc, flags);
1890 goto dump_omp_body;
1891
55d6e7cd 1892 case OMP_CLAUSE:
1893 dump_omp_clause (buffer, node, spc, flags);
1894 is_expr = false;
1895 break;
1896
ea8f3370 1897 case REDUC_MAX_EXPR:
1898 pp_string (buffer, " REDUC_MAX_EXPR < ");
1899 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1900 pp_string (buffer, " > ");
1901 break;
1902
1903 case REDUC_MIN_EXPR:
1904 pp_string (buffer, " REDUC_MIN_EXPR < ");
1905 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1906 pp_string (buffer, " > ");
1907 break;
1908
1909 case REDUC_PLUS_EXPR:
1910 pp_string (buffer, " REDUC_PLUS_EXPR < ");
1911 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1912 pp_string (buffer, " > ");
1913 break;
1914
c6c91d61 1915 case VEC_WIDEN_MULT_HI_EXPR:
1916 pp_string (buffer, " VEC_WIDEN_MULT_HI_EXPR < ");
1917 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1918 pp_string (buffer, ", ");
1919 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1920 pp_string (buffer, " > ");
1921 break;
1922
1923 case VEC_WIDEN_MULT_LO_EXPR:
1924 pp_string (buffer, " VEC_WIDEN_MULT_LO_EXPR < ");
1925 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1926 pp_string (buffer, ", ");
1927 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1928 pp_string (buffer, " > ");
1929 break;
1930
1931 case VEC_UNPACK_HI_EXPR:
1932 pp_string (buffer, " VEC_UNPACK_HI_EXPR < ");
1933 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1934 pp_string (buffer, " > ");
1935 break;
1936
1937 case VEC_UNPACK_LO_EXPR:
1938 pp_string (buffer, " VEC_UNPACK_LO_EXPR < ");
1939 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1940 pp_string (buffer, " > ");
1941 break;
1942
8aa4e142 1943 case VEC_UNPACK_FLOAT_HI_EXPR:
1944 pp_string (buffer, " VEC_UNPACK_FLOAT_HI_EXPR < ");
1945 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1946 pp_string (buffer, " > ");
1947 break;
1948
1949 case VEC_UNPACK_FLOAT_LO_EXPR:
1950 pp_string (buffer, " VEC_UNPACK_FLOAT_LO_EXPR < ");
1951 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1952 pp_string (buffer, " > ");
1953 break;
1954
bb8107e7 1955 case VEC_PACK_TRUNC_EXPR:
1956 pp_string (buffer, " VEC_PACK_TRUNC_EXPR < ");
c6c91d61 1957 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1958 pp_string (buffer, ", ");
1959 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1960 pp_string (buffer, " > ");
1961 break;
8aa4e142 1962
c6c91d61 1963 case VEC_PACK_SAT_EXPR:
1964 pp_string (buffer, " VEC_PACK_SAT_EXPR < ");
1965 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1966 pp_string (buffer, ", ");
1967 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1968 pp_string (buffer, " > ");
1969 break;
8aa4e142 1970
1971 case VEC_PACK_FIX_TRUNC_EXPR:
1972 pp_string (buffer, " VEC_PACK_FIX_TRUNC_EXPR < ");
1973 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1974 pp_string (buffer, ", ");
1975 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1976 pp_string (buffer, " > ");
1977 break;
1978
1e8e9920 1979 case BLOCK:
1980 {
1981 tree t;
1982 pp_string (buffer, "BLOCK");
1983
1984 if (BLOCK_ABSTRACT (node))
1985 pp_string (buffer, " [abstract]");
1986
1987 if (TREE_ASM_WRITTEN (node))
1988 pp_string (buffer, " [written]");
1989
1990 newline_and_indent (buffer, spc + 2);
1991
1992 if (BLOCK_SUPERCONTEXT (node))
1993 {
1994 pp_string (buffer, "SUPERCONTEXT: ");
1995 if (TREE_CODE (BLOCK_SUPERCONTEXT (node)) == BLOCK)
1996 pp_printf (buffer, "BLOCK %p",
1997 (void *)BLOCK_SUPERCONTEXT (node));
1998 else
1999 dump_generic_node (buffer, BLOCK_SUPERCONTEXT (node), 0, flags,
2000 false);
2001 newline_and_indent (buffer, spc + 2);
2002 }
2003
2004 if (BLOCK_SUBBLOCKS (node))
2005 {
2006 pp_string (buffer, "SUBBLOCKS: ");
2007 for (t = BLOCK_SUBBLOCKS (node); t; t = BLOCK_CHAIN (t))
2008 pp_printf (buffer, "%p ", (void *)t);
2009 newline_and_indent (buffer, spc + 2);
2010 }
2011
2012 if (BLOCK_VARS (node))
2013 {
2014 pp_string (buffer, "VARS: ");
2015 for (t = BLOCK_VARS (node); t; t = TREE_CHAIN (t))
2016 {
2017 dump_generic_node (buffer, t, 0, flags, false);
2018 pp_string (buffer, " ");
2019 }
2020 newline_and_indent (buffer, spc + 2);
2021 }
2022
2023 if (BLOCK_ABSTRACT_ORIGIN (node))
2024 {
2025 pp_string (buffer, "ABSTRACT_ORIGIN: ");
2026 if (TREE_CODE (BLOCK_ABSTRACT_ORIGIN (node)) == BLOCK)
2027 pp_printf (buffer, "BLOCK %p",
2028 (void *)BLOCK_ABSTRACT_ORIGIN (node));
2029 else
2030 dump_generic_node (buffer, BLOCK_ABSTRACT_ORIGIN (node), 0, flags,
2031 false);
2032 newline_and_indent (buffer, spc + 2);
2033 }
2034 }
2035 break;
2036
6b8dbb53 2037 case VEC_EXTRACT_EVEN_EXPR:
2038 pp_string (buffer, " VEC_EXTRACT_EVEN_EXPR < ");
2039 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2040 pp_string (buffer, ", ");
2041 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2042 pp_string (buffer, " > ");
2043 break;
2044
2045 case VEC_EXTRACT_ODD_EXPR:
2046 pp_string (buffer, " VEC_EXTRACT_ODD_EXPR < ");
2047 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2048 pp_string (buffer, ", ");
2049 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2050 pp_string (buffer, " > ");
2051 break;
2052
2053 case VEC_INTERLEAVE_HIGH_EXPR:
2054 pp_string (buffer, " VEC_INTERLEAVE_HIGH_EXPR < ");
2055 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2056 pp_string (buffer, ", ");
2057 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2058 pp_string (buffer, " > ");
2059 break;
2060
2061 case VEC_INTERLEAVE_LOW_EXPR:
2062 pp_string (buffer, " VEC_INTERLEAVE_LOW_EXPR < ");
2063 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2064 pp_string (buffer, ", ");
2065 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2066 pp_string (buffer, " > ");
2067 break;
2068
4ee9c684 2069 default:
2070 NIY;
2071 }
2072
2073 if (is_stmt && is_expr)
2074 pp_semicolon (buffer);
b4c01899 2075
2076 /* If we're building a diagnostic, the formatted text will be written
2077 into BUFFER's stream by the caller; otherwise, write it now. */
2078 if (!(flags & TDF_DIAGNOSTIC))
2079 pp_write_text_to_stream (buffer);
4ee9c684 2080
2081 return spc;
2082}
2083
2084/* Print the declaration of a variable. */
2085
75a70cf9 2086void
4ee9c684 2087print_declaration (pretty_printer *buffer, tree t, int spc, int flags)
2088{
4ee9c684 2089 INDENT (spc);
2090
d700b485 2091 if (TREE_CODE (t) == TYPE_DECL)
2092 pp_string (buffer, "typedef ");
2093
5ded8c6f 2094 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL) && DECL_REGISTER (t))
4ee9c684 2095 pp_string (buffer, "register ");
2096
2097 if (TREE_PUBLIC (t) && DECL_EXTERNAL (t))
2098 pp_string (buffer, "extern ");
2099 else if (TREE_STATIC (t))
2100 pp_string (buffer, "static ");
2101
2102 /* Print the type and name. */
2103 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
2104 {
2105 tree tmp;
2106
2107 /* Print array's type. */
2108 tmp = TREE_TYPE (t);
2109 while (TREE_CODE (TREE_TYPE (tmp)) == ARRAY_TYPE)
2110 tmp = TREE_TYPE (tmp);
2111 dump_generic_node (buffer, TREE_TYPE (tmp), spc, flags, false);
2112
2113 /* Print variable's name. */
2114 pp_space (buffer);
2115 dump_generic_node (buffer, t, spc, flags, false);
2116
2117 /* Print the dimensions. */
2118 tmp = TREE_TYPE (t);
2119 while (TREE_CODE (tmp) == ARRAY_TYPE)
2120 {
9b1a6180 2121 dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);
4ee9c684 2122 tmp = TREE_TYPE (tmp);
2123 }
2124 }
d700b485 2125 else if (TREE_CODE (t) == FUNCTION_DECL)
2126 {
2127 dump_generic_node (buffer, TREE_TYPE (TREE_TYPE (t)), spc, flags, false);
2128 pp_space (buffer);
2129 dump_decl_name (buffer, t, flags);
2130 dump_function_declaration (buffer, TREE_TYPE (t), spc, flags);
2131 }
4ee9c684 2132 else
2133 {
2134 /* Print type declaration. */
2135 dump_generic_node (buffer, TREE_TYPE (t), spc, flags, false);
2136
2137 /* Print variable's name. */
2138 pp_space (buffer);
2139 dump_generic_node (buffer, t, spc, flags, false);
2140 }
2141
fbc51f36 2142 if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
2143 {
2144 pp_string (buffer, " __asm__ ");
2145 pp_character (buffer, '(');
2146 dump_generic_node (buffer, DECL_ASSEMBLER_NAME (t), spc, flags, false);
2147 pp_character (buffer, ')');
2148 }
2149
f0b5f617 2150 /* The initial value of a function serves to determine whether the function
4ee9c684 2151 is declared or defined. So the following does not apply to function
2152 nodes. */
2153 if (TREE_CODE (t) != FUNCTION_DECL)
2154 {
2155 /* Print the initial value. */
2156 if (DECL_INITIAL (t))
2157 {
2158 pp_space (buffer);
2159 pp_character (buffer, '=');
2160 pp_space (buffer);
2161 dump_generic_node (buffer, DECL_INITIAL (t), spc, flags, false);
2162 }
2163 }
2164
1e8e9920 2165 if (TREE_CODE (t) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (t))
2166 {
2167 pp_string (buffer, " [value-expr: ");
2168 dump_generic_node (buffer, DECL_VALUE_EXPR (t), spc, flags, false);
2169 pp_character (buffer, ']');
2170 }
2171
4ee9c684 2172 pp_character (buffer, ';');
2173}
2174
2175
2176/* Prints a structure: name, fields, and methods.
2177 FIXME: Still incomplete. */
2178
2179static void
b4b34335 2180print_struct_decl (pretty_printer *buffer, const_tree node, int spc, int flags)
4ee9c684 2181{
2182 /* Print the name of the structure. */
2183 if (TYPE_NAME (node))
2184 {
2185 INDENT (spc);
2186 if (TREE_CODE (node) == RECORD_TYPE)
2187 pp_string (buffer, "struct ");
6374121b 2188 else if ((TREE_CODE (node) == UNION_TYPE
2189 || TREE_CODE (node) == QUAL_UNION_TYPE))
4ee9c684 2190 pp_string (buffer, "union ");
6374121b 2191
4ee9c684 2192 dump_generic_node (buffer, TYPE_NAME (node), spc, 0, false);
2193 }
2194
2195 /* Print the contents of the structure. */
2196 pp_newline (buffer);
2197 INDENT (spc);
2198 pp_character (buffer, '{');
2199 pp_newline (buffer);
2200
2201 /* Print the fields of the structure. */
2202 {
2203 tree tmp;
2204 tmp = TYPE_FIELDS (node);
2205 while (tmp)
2206 {
2207 /* Avoid to print recursively the structure. */
2208 /* FIXME : Not implemented correctly...,
2209 what about the case when we have a cycle in the contain graph? ...
2210 Maybe this could be solved by looking at the scope in which the
2211 structure was declared. */
2212 if (TREE_TYPE (tmp) != node
6374121b 2213 || (TREE_CODE (TREE_TYPE (tmp)) == POINTER_TYPE
2214 && TREE_TYPE (TREE_TYPE (tmp)) != node))
4ee9c684 2215 {
2216 print_declaration (buffer, tmp, spc+2, flags);
2217 pp_newline (buffer);
2218 }
4ee9c684 2219 tmp = TREE_CHAIN (tmp);
2220 }
2221 }
2222 INDENT (spc);
2223 pp_character (buffer, '}');
2224}
2225
2226/* Return the priority of the operator OP.
2227
2228 From lowest to highest precedence with either left-to-right (L-R)
2229 or right-to-left (R-L) associativity]:
2230
2231 1 [L-R] ,
2232 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
2233 3 [R-L] ?:
2234 4 [L-R] ||
2235 5 [L-R] &&
2236 6 [L-R] |
2237 7 [L-R] ^
2238 8 [L-R] &
2239 9 [L-R] == !=
2240 10 [L-R] < <= > >=
2241 11 [L-R] << >>
2242 12 [L-R] + -
2243 13 [L-R] * / %
2244 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
2245 15 [L-R] fn() [] -> .
2246
2247 unary +, - and * have higher precedence than the corresponding binary
2248 operators. */
2249
2250static int
7ecb5bb2 2251op_prio (const_tree op)
4ee9c684 2252{
2253 if (op == NULL)
2254 return 9999;
2255
2256 switch (TREE_CODE (op))
2257 {
2258 case TREE_LIST:
2259 case COMPOUND_EXPR:
2260 case BIND_EXPR:
2261 return 1;
2262
2263 case MODIFY_EXPR:
2264 case INIT_EXPR:
2265 return 2;
2266
2267 case COND_EXPR:
2268 return 3;
2269
2270 case TRUTH_OR_EXPR:
2271 case TRUTH_ORIF_EXPR:
2272 return 4;
2273
2274 case TRUTH_AND_EXPR:
2275 case TRUTH_ANDIF_EXPR:
2276 return 5;
2277
2278 case BIT_IOR_EXPR:
2279 return 6;
2280
2281 case BIT_XOR_EXPR:
2282 case TRUTH_XOR_EXPR:
2283 return 7;
2284
2285 case BIT_AND_EXPR:
2286 return 8;
2287
2288 case EQ_EXPR:
2289 case NE_EXPR:
2290 return 9;
2291
318a728f 2292 case UNLT_EXPR:
2293 case UNLE_EXPR:
2294 case UNGT_EXPR:
2295 case UNGE_EXPR:
2296 case UNEQ_EXPR:
2297 case LTGT_EXPR:
2298 case ORDERED_EXPR:
2299 case UNORDERED_EXPR:
4ee9c684 2300 case LT_EXPR:
2301 case LE_EXPR:
2302 case GT_EXPR:
2303 case GE_EXPR:
2304 return 10;
2305
2306 case LSHIFT_EXPR:
2307 case RSHIFT_EXPR:
2308 case LROTATE_EXPR:
2309 case RROTATE_EXPR:
2310 return 11;
2311
4a61a337 2312 case WIDEN_SUM_EXPR:
4ee9c684 2313 case PLUS_EXPR:
0de36bdb 2314 case POINTER_PLUS_EXPR:
4ee9c684 2315 case MINUS_EXPR:
2316 return 12;
2317
c6c91d61 2318 case VEC_WIDEN_MULT_HI_EXPR:
2319 case VEC_WIDEN_MULT_LO_EXPR:
4a61a337 2320 case WIDEN_MULT_EXPR:
2321 case DOT_PROD_EXPR:
4ee9c684 2322 case MULT_EXPR:
2323 case TRUNC_DIV_EXPR:
2324 case CEIL_DIV_EXPR:
2325 case FLOOR_DIV_EXPR:
2326 case ROUND_DIV_EXPR:
2327 case RDIV_EXPR:
2328 case EXACT_DIV_EXPR:
2329 case TRUNC_MOD_EXPR:
2330 case CEIL_MOD_EXPR:
2331 case FLOOR_MOD_EXPR:
2332 case ROUND_MOD_EXPR:
2333 return 13;
2334
2335 case TRUTH_NOT_EXPR:
2336 case BIT_NOT_EXPR:
2337 case POSTINCREMENT_EXPR:
2338 case POSTDECREMENT_EXPR:
2339 case PREINCREMENT_EXPR:
2340 case PREDECREMENT_EXPR:
2341 case NEGATE_EXPR:
b056d812 2342 case ALIGN_INDIRECT_REF:
2343 case MISALIGNED_INDIRECT_REF:
4ee9c684 2344 case INDIRECT_REF:
2345 case ADDR_EXPR:
2346 case FLOAT_EXPR:
72dd6141 2347 CASE_CONVERT:
4ee9c684 2348 case FIX_TRUNC_EXPR:
4ee9c684 2349 case TARGET_EXPR:
2350 return 14;
2351
2352 case CALL_EXPR:
2353 case ARRAY_REF:
6374121b 2354 case ARRAY_RANGE_REF:
4ee9c684 2355 case COMPONENT_REF:
2356 return 15;
2357
2358 /* Special expressions. */
2359 case MIN_EXPR:
2360 case MAX_EXPR:
2361 case ABS_EXPR:
2362 case REALPART_EXPR:
2363 case IMAGPART_EXPR:
ea8f3370 2364 case REDUC_MAX_EXPR:
2365 case REDUC_MIN_EXPR:
2366 case REDUC_PLUS_EXPR:
925c62d4 2367 case VEC_LSHIFT_EXPR:
2368 case VEC_RSHIFT_EXPR:
c6c91d61 2369 case VEC_UNPACK_HI_EXPR:
2370 case VEC_UNPACK_LO_EXPR:
8aa4e142 2371 case VEC_UNPACK_FLOAT_HI_EXPR:
2372 case VEC_UNPACK_FLOAT_LO_EXPR:
bb8107e7 2373 case VEC_PACK_TRUNC_EXPR:
c6c91d61 2374 case VEC_PACK_SAT_EXPR:
4ee9c684 2375 return 16;
2376
2377 case SAVE_EXPR:
2378 case NON_LVALUE_EXPR:
2379 return op_prio (TREE_OPERAND (op, 0));
2380
2381 default:
2382 /* Return an arbitrarily high precedence to avoid surrounding single
2383 VAR_DECLs in ()s. */
2384 return 9999;
2385 }
2386}
2387
2388
ad4a85ad 2389/* Return the symbol associated with operator CODE. */
4ee9c684 2390
ad4a85ad 2391const char *
2392op_symbol_code (enum tree_code code)
4ee9c684 2393{
1e8e9920 2394 switch (code)
4ee9c684 2395 {
2396 case MODIFY_EXPR:
2397 return "=";
2398
2399 case TRUTH_OR_EXPR:
2400 case TRUTH_ORIF_EXPR:
2401 return "||";
2402
2403 case TRUTH_AND_EXPR:
2404 case TRUTH_ANDIF_EXPR:
2405 return "&&";
2406
2407 case BIT_IOR_EXPR:
2408 return "|";
2409
2410 case TRUTH_XOR_EXPR:
2411 case BIT_XOR_EXPR:
2412 return "^";
2413
2414 case ADDR_EXPR:
2415 case BIT_AND_EXPR:
2416 return "&";
2417
318a728f 2418 case ORDERED_EXPR:
2419 return "ord";
2420 case UNORDERED_EXPR:
2421 return "unord";
2422
4ee9c684 2423 case EQ_EXPR:
4ee9c684 2424 return "==";
318a728f 2425 case UNEQ_EXPR:
2426 return "u==";
4ee9c684 2427
2428 case NE_EXPR:
2429 return "!=";
2430
2431 case LT_EXPR:
4ee9c684 2432 return "<";
318a728f 2433 case UNLT_EXPR:
2434 return "u<";
4ee9c684 2435
2436 case LE_EXPR:
4ee9c684 2437 return "<=";
318a728f 2438 case UNLE_EXPR:
2439 return "u<=";
4ee9c684 2440
2441 case GT_EXPR:
4ee9c684 2442 return ">";
318a728f 2443 case UNGT_EXPR:
2444 return "u>";
4ee9c684 2445
2446 case GE_EXPR:
4ee9c684 2447 return ">=";
318a728f 2448 case UNGE_EXPR:
2449 return "u>=";
2450
2451 case LTGT_EXPR:
2452 return "<>";
4ee9c684 2453
2454 case LSHIFT_EXPR:
2455 return "<<";
2456
2457 case RSHIFT_EXPR:
2458 return ">>";
2459
01329d30 2460 case LROTATE_EXPR:
2461 return "r<<";
2462
2463 case RROTATE_EXPR:
2464 return "r>>";
2465
925c62d4 2466 case VEC_LSHIFT_EXPR:
2467 return "v<<";
2468
2469 case VEC_RSHIFT_EXPR:
2470 return "v>>";
0de36bdb 2471
2472 case POINTER_PLUS_EXPR:
2473 return "+";
925c62d4 2474
4ee9c684 2475 case PLUS_EXPR:
2476 return "+";
2477
ea8f3370 2478 case REDUC_PLUS_EXPR:
2479 return "r+";
2480
4a61a337 2481 case WIDEN_SUM_EXPR:
2482 return "w+";
2483
2484 case WIDEN_MULT_EXPR:
2485 return "w*";
2486
4ee9c684 2487 case NEGATE_EXPR:
2488 case MINUS_EXPR:
2489 return "-";
2490
2491 case BIT_NOT_EXPR:
2492 return "~";
2493
2494 case TRUTH_NOT_EXPR:
2495 return "!";
2496
2497 case MULT_EXPR:
2498 case INDIRECT_REF:
2499 return "*";
2500
b056d812 2501 case ALIGN_INDIRECT_REF:
2502 return "A*";
2503
2504 case MISALIGNED_INDIRECT_REF:
2505 return "M*";
2506
4ee9c684 2507 case TRUNC_DIV_EXPR:
153536df 2508 case RDIV_EXPR:
2509 return "/";
2510
4ee9c684 2511 case CEIL_DIV_EXPR:
153536df 2512 return "/[cl]";
2513
4ee9c684 2514 case FLOOR_DIV_EXPR:
153536df 2515 return "/[fl]";
2516
4ee9c684 2517 case ROUND_DIV_EXPR:
153536df 2518 return "/[rd]";
2519
4ee9c684 2520 case EXACT_DIV_EXPR:
153536df 2521 return "/[ex]";
4ee9c684 2522
2523 case TRUNC_MOD_EXPR:
153536df 2524 return "%";
2525
4ee9c684 2526 case CEIL_MOD_EXPR:
153536df 2527 return "%[cl]";
2528
4ee9c684 2529 case FLOOR_MOD_EXPR:
153536df 2530 return "%[fl]";
2531
4ee9c684 2532 case ROUND_MOD_EXPR:
153536df 2533 return "%[rd]";
4ee9c684 2534
2535 case PREDECREMENT_EXPR:
2536 return " --";
2537
2538 case PREINCREMENT_EXPR:
2539 return " ++";
2540
2541 case POSTDECREMENT_EXPR:
2542 return "-- ";
2543
2544 case POSTINCREMENT_EXPR:
2545 return "++ ";
2546
1e8e9920 2547 case MAX_EXPR:
2548 return "max";
2549
2550 case MIN_EXPR:
2551 return "min";
2552
4ee9c684 2553 default:
2554 return "<<< ??? >>>";
2555 }
2556}
2557
ad4a85ad 2558/* Return the symbol associated with operator OP. */
2559
1e8e9920 2560static const char *
b4b34335 2561op_symbol (const_tree op)
1e8e9920 2562{
ad4a85ad 2563 return op_symbol_code (TREE_CODE (op));
1e8e9920 2564}
2565
4ee9c684 2566/* Prints the name of a CALL_EXPR. */
2567
2568static void
b4b34335 2569print_call_name (pretty_printer *buffer, const_tree node)
4ee9c684 2570{
2571 tree op0;
2572
8c0963c4 2573 gcc_assert (TREE_CODE (node) == CALL_EXPR);
4ee9c684 2574
c2f47e15 2575 op0 = CALL_EXPR_FN (node);
4ee9c684 2576
2577 if (TREE_CODE (op0) == NON_LVALUE_EXPR)
2578 op0 = TREE_OPERAND (op0, 0);
2579
2580 switch (TREE_CODE (op0))
2581 {
2582 case VAR_DECL:
2583 case PARM_DECL:
a1080ab2 2584 dump_function_name (buffer, op0);
4ee9c684 2585 break;
2586
2587 case ADDR_EXPR:
2588 case INDIRECT_REF:
2589 case NOP_EXPR:
2590 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
2591 break;
2592
2593 case COND_EXPR:
2594 pp_string (buffer, "(");
2595 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
2596 pp_string (buffer, ") ? ");
2597 dump_generic_node (buffer, TREE_OPERAND (op0, 1), 0, 0, false);
2598 pp_string (buffer, " : ");
2599 dump_generic_node (buffer, TREE_OPERAND (op0, 2), 0, 0, false);
2600 break;
2601
2602 case COMPONENT_REF:
2603 /* The function is a pointer contained in a structure. */
2604 if (TREE_CODE (TREE_OPERAND (op0, 0)) == INDIRECT_REF ||
2605 TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
a1080ab2 2606 dump_function_name (buffer, TREE_OPERAND (op0, 1));
4ee9c684 2607 else
2608 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
2609 /* else
2610 We can have several levels of structures and a function
2611 pointer inside. This is not implemented yet... */
2612 /* NIY;*/
2613 break;
2614
2615 case ARRAY_REF:
2616 if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
a1080ab2 2617 dump_function_name (buffer, TREE_OPERAND (op0, 0));
4ee9c684 2618 else
2619 dump_generic_node (buffer, op0, 0, 0, false);
2620 break;
2621
2622 case SSA_NAME:
215e2f1d 2623 case OBJ_TYPE_REF:
4ee9c684 2624 dump_generic_node (buffer, op0, 0, 0, false);
2625 break;
2626
2627 default:
2628 NIY;
2629 }
2630}
2631
2632/* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
2633
2634static void
2635pretty_print_string (pretty_printer *buffer, const char *str)
2636{
2637 if (str == NULL)
2638 return;
2639
2640 while (*str)
2641 {
2642 switch (str[0])
2643 {
2644 case '\b':
2645 pp_string (buffer, "\\b");
2646 break;
2647
2648 case '\f':
2649 pp_string (buffer, "\\f");
2650 break;
2651
2652 case '\n':
2653 pp_string (buffer, "\\n");
2654 break;
2655
2656 case '\r':
2657 pp_string (buffer, "\\r");
2658 break;
2659
2660 case '\t':
2661 pp_string (buffer, "\\t");
2662 break;
2663
2664 case '\v':
2665 pp_string (buffer, "\\v");
2666 break;
2667
2668 case '\\':
2669 pp_string (buffer, "\\\\");
2670 break;
2671
2672 case '\"':
2673 pp_string (buffer, "\\\"");
2674 break;
2675
2676 case '\'':
2677 pp_string (buffer, "\\'");
2678 break;
2679
32a9fcf7 2680 /* No need to handle \0; the loop terminates on \0. */
4ee9c684 2681
2682 case '\1':
2683 pp_string (buffer, "\\1");
2684 break;
2685
2686 case '\2':
2687 pp_string (buffer, "\\2");
2688 break;
2689
2690 case '\3':
2691 pp_string (buffer, "\\3");
2692 break;
2693
2694 case '\4':
2695 pp_string (buffer, "\\4");
2696 break;
2697
2698 case '\5':
2699 pp_string (buffer, "\\5");
2700 break;
2701
2702 case '\6':
2703 pp_string (buffer, "\\6");
2704 break;
2705
2706 case '\7':
2707 pp_string (buffer, "\\7");
2708 break;
2709
2710 default:
2711 pp_character (buffer, str[0]);
2712 break;
2713 }
2714 str++;
2715 }
2716}
2717
2718static void
2719maybe_init_pretty_print (FILE *file)
2720{
2721 if (!initialized)
2722 {
2723 pp_construct (&buffer, /* prefix */NULL, /* line-width */0);
2724 pp_needs_newline (&buffer) = true;
2725 initialized = 1;
2726 }
2727
2728 buffer.buffer->stream = file;
2729}
2730
2731static void
2732newline_and_indent (pretty_printer *buffer, int spc)
2733{
2734 pp_newline (buffer);
2735 INDENT (spc);
2736}
Mirror of https://gcc.gnu.org/git/gcc.git