Line data Source code
1 : /* Pretty formatting of GENERIC trees in C syntax.
2 : Copyright (C) 2001-2026 Free Software Foundation, Inc.
3 : Adapted from c-pretty-print.cc by Diego Novillo <dnovillo@redhat.com>
4 :
5 : This file is part of GCC.
6 :
7 : GCC is free software; you can redistribute it and/or modify it under
8 : the terms of the GNU General Public License as published by the Free
9 : Software Foundation; either version 3, or (at your option) any later
10 : version.
11 :
12 : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 : WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 : FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 : for more details.
16 :
17 : You should have received a copy of the GNU General Public License
18 : along with GCC; see the file COPYING3. If not see
19 : <http://www.gnu.org/licenses/>. */
20 :
21 : #include "config.h"
22 : #include "system.h"
23 : #include "coretypes.h"
24 : #include "backend.h"
25 : #include "rtl.h"
26 : #include "tree.h"
27 : #include "predict.h"
28 : #include "cgraph.h"
29 : #include "tree-pretty-print.h"
30 : #include "stor-layout.h"
31 : #include "langhooks.h"
32 : #include "tree-iterator.h"
33 : #include "dumpfile.h"
34 : #include "internal-fn.h"
35 : #include "gomp-constants.h"
36 : #include "gimple.h"
37 : #include "fold-const.h"
38 : #include "omp-general.h"
39 :
40 : /* Routines in this file get invoked via the default tree printer
41 : used by diagnostics and thus they are called from pp_printf which
42 : isn't reentrant. Avoid using pp_printf in this file. */
43 : #pragma GCC poison pp_printf
44 :
45 : /* Disable warnings about quoting issues in the pp_xxx calls below
46 : that (intentionally) don't follow GCC diagnostic conventions. */
47 : #if __GNUC__ >= 10
48 : # pragma GCC diagnostic push
49 : # pragma GCC diagnostic ignored "-Wformat-diag"
50 : #endif
51 :
52 : /* Local functions, macros and variables. */
53 : static const char *op_symbol (const_tree, dump_flags_t = TDF_NONE);
54 : static void newline_and_indent (pretty_printer *, int);
55 : static void maybe_init_pretty_print (FILE *);
56 : static void print_struct_decl (pretty_printer *, const_tree, int, dump_flags_t);
57 : static void do_niy (pretty_printer *, const_tree, int, dump_flags_t);
58 :
59 : #define INDENT(SPACE) do { \
60 : int i; for (i = 0; i<SPACE; i++) pp_space (pp); } while (0)
61 :
62 : #define NIY do_niy (pp, node, spc, flags)
63 :
64 : static pretty_printer *tree_pp;
65 :
66 : /* Try to print something for an unknown tree code. */
67 :
68 : static void
69 13277 : do_niy (pretty_printer *pp, const_tree node, int spc, dump_flags_t flags)
70 : {
71 13277 : int i, len;
72 :
73 13277 : pp_string (pp, "<<< Unknown tree: ");
74 13277 : pp_string (pp, get_tree_code_name (TREE_CODE (node)));
75 :
76 13277 : if (EXPR_P (node))
77 : {
78 13061 : len = TREE_OPERAND_LENGTH (node);
79 43174 : for (i = 0; i < len; ++i)
80 : {
81 17052 : newline_and_indent (pp, spc+2);
82 17052 : dump_generic_node (pp, TREE_OPERAND (node, i), spc+2, flags, false);
83 : }
84 : }
85 :
86 13277 : pp_string (pp, " >>>");
87 13277 : }
88 :
89 : /* Debugging function to print out a generic expression. */
90 :
91 : DEBUG_FUNCTION void
92 1 : debug_generic_expr (tree t)
93 : {
94 1 : print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS);
95 1 : fprintf (stderr, "\n");
96 1 : }
97 :
98 : /* Debugging function to print out a generic statement. */
99 :
100 : DEBUG_FUNCTION void
101 0 : debug_generic_stmt (tree t)
102 : {
103 0 : print_generic_stmt (stderr, t, TDF_VOPS|TDF_MEMSYMS);
104 0 : fprintf (stderr, "\n");
105 0 : }
106 :
107 : /* Debugging function to print out a chain of trees . */
108 :
109 : DEBUG_FUNCTION void
110 0 : debug_tree_chain (tree t)
111 : {
112 0 : hash_set<tree> seen;
113 :
114 0 : while (t)
115 : {
116 0 : print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID);
117 0 : fprintf (stderr, " ");
118 0 : t = TREE_CHAIN (t);
119 0 : if (seen.add (t))
120 : {
121 0 : fprintf (stderr, "... [cycled back to ");
122 0 : print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID);
123 0 : fprintf (stderr, "]");
124 0 : break;
125 : }
126 : }
127 0 : fprintf (stderr, "\n");
128 0 : }
129 :
130 : /* Prints declaration DECL to the FILE with details specified by FLAGS. */
131 : void
132 289325 : print_generic_decl (FILE *file, tree decl, dump_flags_t flags)
133 : {
134 289325 : maybe_init_pretty_print (file);
135 289325 : print_declaration (tree_pp, decl, 2, flags);
136 289325 : pp_write_text_to_stream (tree_pp);
137 289325 : }
138 :
139 : /* Print tree T, and its successors, on file FILE. FLAGS specifies details
140 : to show in the dump. See TDF_* in dumpfile.h. */
141 :
142 : void
143 71132 : print_generic_stmt (FILE *file, tree t, dump_flags_t flags)
144 : {
145 71132 : maybe_init_pretty_print (file);
146 71132 : dump_generic_node (tree_pp, t, 0, flags, true);
147 71132 : pp_newline_and_flush (tree_pp);
148 71132 : }
149 :
150 : /* Print tree T, and its successors, on file FILE. FLAGS specifies details
151 : to show in the dump. See TDF_* in dumpfile.h. The output is indented by
152 : INDENT spaces. */
153 :
154 : void
155 6241 : print_generic_stmt_indented (FILE *file, tree t, dump_flags_t flags, int indent)
156 : {
157 6241 : int i;
158 :
159 6241 : maybe_init_pretty_print (file);
160 :
161 12482 : for (i = 0; i < indent; i++)
162 0 : pp_space (tree_pp);
163 6241 : dump_generic_node (tree_pp, t, indent, flags, true);
164 6241 : pp_newline_and_flush (tree_pp);
165 6241 : }
166 :
167 : /* Print a single expression T on file FILE. FLAGS specifies details to show
168 : in the dump. See TDF_* in dumpfile.h. */
169 :
170 : void
171 5752565 : print_generic_expr (FILE *file, tree t, dump_flags_t flags)
172 : {
173 5752565 : maybe_init_pretty_print (file);
174 5752565 : dump_generic_node (tree_pp, t, 0, flags, false);
175 5752565 : pp_flush (tree_pp);
176 5752565 : }
177 :
178 : /* Print a single expression T to string, and return it. The caller
179 : must free the returned memory. */
180 :
181 : char *
182 62633 : print_generic_expr_to_str (tree t)
183 : {
184 62633 : pretty_printer pp;
185 62633 : dump_generic_node (&pp, t, 0, TDF_VOPS|TDF_MEMSYMS, false);
186 62633 : return xstrdup (pp_formatted_text (&pp));
187 62633 : }
188 :
189 : /* Dump NAME, an IDENTIFIER_POINTER, sanitized so that D<num> sequences
190 : in it are replaced with Dxxxx, as long as they are at the start or
191 : preceded by $ and at the end or followed by $. See make_fancy_name
192 : in tree-sra.cc. */
193 :
194 : static void
195 2544 : dump_fancy_name (pretty_printer *pp, tree name)
196 : {
197 2544 : int cnt = 0;
198 2544 : int length = IDENTIFIER_LENGTH (name);
199 2544 : const char *n = IDENTIFIER_POINTER (name);
200 2544 : do
201 : {
202 2544 : n = strchr (n, 'D');
203 2544 : if (n == NULL)
204 : break;
205 0 : if (ISDIGIT (n[1])
206 0 : && (n == IDENTIFIER_POINTER (name) || n[-1] == '$'))
207 : {
208 : int l = 2;
209 0 : while (ISDIGIT (n[l]))
210 0 : l++;
211 0 : if (n[l] == '\0' || n[l] == '$')
212 : {
213 0 : cnt++;
214 0 : length += 5 - l;
215 : }
216 0 : n += l;
217 : }
218 : else
219 0 : n++;
220 : }
221 : while (1);
222 2544 : if (cnt == 0)
223 : {
224 2544 : pp_tree_identifier (pp, name);
225 2544 : return;
226 : }
227 :
228 0 : char *str = XNEWVEC (char, length + 1);
229 0 : char *p = str;
230 0 : const char *q;
231 0 : q = n = IDENTIFIER_POINTER (name);
232 0 : do
233 : {
234 0 : q = strchr (q, 'D');
235 0 : if (q == NULL)
236 : break;
237 0 : if (ISDIGIT (q[1])
238 0 : && (q == IDENTIFIER_POINTER (name) || q[-1] == '$'))
239 : {
240 : int l = 2;
241 0 : while (ISDIGIT (q[l]))
242 0 : l++;
243 0 : if (q[l] == '\0' || q[l] == '$')
244 : {
245 0 : memcpy (p, n, q - n);
246 0 : memcpy (p + (q - n), "Dxxxx", 5);
247 0 : p += (q - n) + 5;
248 0 : n = q + l;
249 : }
250 0 : q += l;
251 : }
252 : else
253 0 : q++;
254 : }
255 : while (1);
256 0 : memcpy (p, n, IDENTIFIER_LENGTH (name) - (n - IDENTIFIER_POINTER (name)));
257 0 : str[length] = '\0';
258 0 : if (pp_translate_identifiers (pp))
259 : {
260 0 : const char *text = identifier_to_locale (str);
261 0 : pp_append_text (pp, text, text + strlen (text));
262 : }
263 : else
264 0 : pp_append_text (pp, str, str + length);
265 0 : XDELETEVEC (str);
266 : }
267 :
268 : /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
269 : in FLAGS. */
270 :
271 : static void
272 5928257 : dump_decl_name (pretty_printer *pp, tree node, dump_flags_t flags)
273 : {
274 5928257 : tree name = DECL_NAME (node);
275 5928257 : if (name)
276 : {
277 5417649 : if ((flags & TDF_ASMNAME)
278 17309 : && HAS_DECL_ASSEMBLER_NAME_P (node)
279 5432946 : && DECL_ASSEMBLER_NAME_SET_P (node))
280 1616 : pp_tree_identifier (pp, DECL_ASSEMBLER_NAME_RAW (node));
281 : /* For -fcompare-debug don't dump DECL_NAMELESS names at all,
282 : -g might have created more fancy names and their indexes
283 : could get out of sync. Usually those should be DECL_IGNORED_P
284 : too, SRA can create even non-DECL_IGNORED_P DECL_NAMELESS fancy
285 : names, let's hope those never get out of sync after doing the
286 : dump_fancy_name sanitization. */
287 5416033 : else if ((flags & TDF_COMPARE_DEBUG)
288 43344 : && DECL_NAMELESS (node)
289 5421363 : && DECL_IGNORED_P (node))
290 : name = NULL_TREE;
291 : /* For DECL_NAMELESS names look for embedded uids in the
292 : names and sanitize them for TDF_NOUID. */
293 5411357 : else if ((flags & TDF_NOUID) && DECL_NAMELESS (node))
294 1276 : dump_fancy_name (pp, name);
295 : else
296 5410081 : pp_tree_identifier (pp, name);
297 : }
298 5928257 : char uid_sep = (flags & TDF_GIMPLE) ? '_' : '.';
299 5928257 : if ((flags & TDF_UID) || name == NULL_TREE)
300 : {
301 532891 : if (TREE_CODE (node) == LABEL_DECL && LABEL_DECL_UID (node) != -1)
302 : {
303 3 : pp_character (pp, 'L');
304 3 : pp_character (pp, uid_sep);
305 3 : pp_decimal_int (pp, (int) LABEL_DECL_UID (node));
306 : }
307 532888 : else if (TREE_CODE (node) == DEBUG_EXPR_DECL)
308 : {
309 3906 : if (flags & TDF_NOUID)
310 0 : pp_string (pp, "D#xxxx");
311 : else
312 : {
313 3906 : pp_string (pp, "D#");
314 3906 : pp_decimal_int (pp, (int) DEBUG_TEMP_UID (node));
315 : }
316 : }
317 : else
318 : {
319 528982 : char c = TREE_CODE (node) == CONST_DECL ? 'C' : 'D';
320 528982 : pp_character (pp, c);
321 528982 : pp_character (pp, uid_sep);
322 528982 : if (flags & TDF_NOUID)
323 7459 : pp_string (pp, "xxxx");
324 : else
325 521523 : pp_scalar (pp, "%u", DECL_UID (node));
326 : }
327 : }
328 5928257 : if ((flags & TDF_ALIAS) && DECL_PT_UID (node) != DECL_UID (node))
329 : {
330 2 : if (flags & TDF_NOUID)
331 0 : pp_string (pp, "ptD.xxxx");
332 : else
333 : {
334 2 : pp_string (pp, "ptD.");
335 2 : pp_scalar (pp, "%u", DECL_PT_UID (node));
336 : }
337 : }
338 5928257 : }
339 :
340 : /* Like the above, but used for pretty printing function calls. */
341 :
342 : static void
343 179161 : dump_function_name (pretty_printer *pp, tree node, dump_flags_t flags)
344 : {
345 179161 : if (CONVERT_EXPR_P (node))
346 0 : node = TREE_OPERAND (node, 0);
347 179161 : if (DECL_NAME (node) && (flags & TDF_ASMNAME) == 0)
348 : {
349 178776 : pp_string (pp, lang_hooks.decl_printable_name (node, 1));
350 178776 : if (flags & TDF_UID)
351 : {
352 0 : char uid_sep = (flags & TDF_GIMPLE) ? '_' : '.';
353 0 : pp_character (pp, 'D');
354 0 : pp_character (pp, uid_sep);
355 0 : pp_scalar (pp, "%u", DECL_UID (node));
356 : }
357 : }
358 : else
359 385 : dump_decl_name (pp, node, flags);
360 179161 : }
361 :
362 : /* Dump a function declaration. NODE is the FUNCTION_TYPE. PP, SPC and
363 : FLAGS are as in dump_generic_node. */
364 :
365 : static void
366 16369 : dump_function_declaration (pretty_printer *pp, tree node,
367 : int spc, dump_flags_t flags)
368 : {
369 16369 : bool wrote_arg = false;
370 16369 : tree arg;
371 :
372 16369 : pp_space (pp);
373 16369 : pp_left_paren (pp);
374 :
375 : /* Print the argument types. */
376 16369 : arg = TYPE_ARG_TYPES (node);
377 44802 : while (arg && arg != void_list_node && arg != error_mark_node)
378 : {
379 28433 : if (wrote_arg)
380 : {
381 17404 : pp_comma (pp);
382 17404 : pp_space (pp);
383 : }
384 28433 : wrote_arg = true;
385 28433 : dump_generic_node (pp, TREE_VALUE (arg), spc, flags, false);
386 28433 : arg = TREE_CHAIN (arg);
387 : }
388 :
389 : /* Drop the trailing void_type_node if we had any previous argument. */
390 16369 : if (arg == void_list_node && !wrote_arg)
391 2841 : pp_string (pp, "void");
392 : /* Properly dump vararg function types. */
393 13528 : else if (!arg && wrote_arg)
394 115 : pp_string (pp, ", ...");
395 : /* Avoid printing any arg for unprototyped functions. */
396 :
397 16369 : pp_right_paren (pp);
398 16369 : }
399 :
400 : /* Dump the domain associated with an array. */
401 :
402 : static void
403 104837 : dump_array_domain (pretty_printer *pp, tree domain, int spc, dump_flags_t flags)
404 : {
405 104837 : pp_left_bracket (pp);
406 104837 : if (domain)
407 : {
408 104519 : tree min = TYPE_MIN_VALUE (domain);
409 104519 : tree max = TYPE_MAX_VALUE (domain);
410 :
411 104519 : if (min && max
412 81852 : && integer_zerop (min)
413 181618 : && tree_fits_shwi_p (max))
414 72434 : pp_wide_integer (pp, tree_to_shwi (max) + 1);
415 : else
416 : {
417 32085 : if (min)
418 32085 : dump_generic_node (pp, min, spc, flags, false);
419 32085 : pp_colon (pp);
420 32085 : if (max)
421 9418 : dump_generic_node (pp, max, spc, flags, false);
422 : }
423 : }
424 : else
425 318 : pp_string (pp, "<unknown>");
426 104837 : pp_right_bracket (pp);
427 104837 : }
428 :
429 :
430 : /* Dump OpenMP iterators ITER. */
431 :
432 : static void
433 137 : dump_omp_iterators (pretty_printer *pp, tree iter, int spc, dump_flags_t flags)
434 : {
435 137 : pp_string (pp, "iterator(");
436 479 : for (tree it = iter; it; it = TREE_CHAIN (it))
437 : {
438 205 : if (it != iter)
439 68 : pp_string (pp, ", ");
440 205 : dump_generic_node (pp, TREE_TYPE (OMP_ITERATOR_VAR (it)), spc, flags,
441 : false);
442 205 : pp_space (pp);
443 205 : dump_generic_node (pp, OMP_ITERATOR_VAR (it), spc, flags, false);
444 205 : pp_equal (pp);
445 205 : dump_generic_node (pp, OMP_ITERATOR_BEGIN (it), spc, flags, false);
446 205 : pp_colon (pp);
447 205 : dump_generic_node (pp, OMP_ITERATOR_END (it), spc, flags, false);
448 205 : pp_colon (pp);
449 205 : dump_generic_node (pp, OMP_ITERATOR_STEP (it), spc, flags, false);
450 : }
451 137 : if (OMP_ITERATOR_EXPANDED_P (iter))
452 : {
453 119 : pp_string (pp, ", loop_label=");
454 119 : dump_generic_node (pp, OMP_ITERATOR_LABEL (iter), spc, flags, false);
455 119 : pp_string (pp, ", elems=");
456 119 : dump_generic_node (pp, OMP_ITERATOR_ELEMS (iter), spc, flags, false);
457 119 : pp_string (pp, ", index=");
458 119 : dump_generic_node (pp, OMP_ITERATOR_INDEX (iter), spc, flags, false);
459 : /* The count field is not used yet. */
460 : }
461 137 : pp_right_paren (pp);
462 137 : }
463 :
464 : /* Dump OpenMP's prefer_type of the init clause. */
465 :
466 : static void
467 251 : dump_omp_init_prefer_type (pretty_printer *pp, tree t)
468 : {
469 251 : if (t == NULL_TREE)
470 : return;
471 119 : pp_string (pp, "prefer_type(");
472 119 : const char *str = TREE_STRING_POINTER (t);
473 527 : while (str[0] == (char) GOMP_INTEROP_IFR_SEPARATOR)
474 : {
475 408 : bool has_fr = false;
476 408 : pp_character (pp, '{');
477 408 : str++;
478 794 : while (str[0] != (char) GOMP_INTEROP_IFR_SEPARATOR)
479 : {
480 386 : if (has_fr)
481 0 : pp_character (pp, ',');
482 386 : has_fr = true;
483 386 : pp_string (pp, "fr(\"");
484 386 : pp_string (pp, omp_get_name_from_fr_id (str[0]));
485 386 : pp_string (pp, "\")");
486 386 : str++;
487 : }
488 408 : str++;
489 408 : if (has_fr && str[0] != '\0')
490 52 : pp_character (pp, ',');
491 534 : while (str[0] != '\0')
492 : {
493 126 : pp_string (pp, "attr(\"");
494 126 : pp_string (pp, str);
495 126 : pp_string (pp, "\")");
496 126 : str += strlen (str) + 1;
497 126 : if (str[0] != '\0')
498 52 : pp_character (pp, ',');
499 : }
500 408 : str++;
501 408 : pp_character (pp, '}');
502 408 : if (str[0] != '\0')
503 289 : pp_string (pp, ", ");
504 : }
505 119 : pp_right_paren (pp);
506 : }
507 :
508 : /* Dump OMP clause CLAUSE, without following OMP_CLAUSE_CHAIN.
509 :
510 : PP, CLAUSE, SPC and FLAGS are as in dump_generic_node. */
511 :
512 : static void
513 30019 : dump_omp_clause (pretty_printer *pp, tree clause, int spc, dump_flags_t flags)
514 : {
515 30019 : const char *name;
516 30019 : const char *modifier = NULL;
517 30019 : switch (OMP_CLAUSE_CODE (clause))
518 : {
519 3272 : case OMP_CLAUSE_PRIVATE:
520 3272 : name = "private";
521 3272 : goto print_remap;
522 1119 : case OMP_CLAUSE_SHARED:
523 1119 : name = "shared";
524 1119 : goto print_remap;
525 1551 : case OMP_CLAUSE_FIRSTPRIVATE:
526 1551 : name = "firstprivate";
527 1551 : goto print_remap;
528 1166 : case OMP_CLAUSE_LASTPRIVATE:
529 1166 : name = "lastprivate";
530 1166 : if (OMP_CLAUSE_LASTPRIVATE_CONDITIONAL (clause))
531 7 : modifier = "conditional:";
532 1166 : goto print_remap;
533 4 : case OMP_CLAUSE_COPYIN:
534 4 : name = "copyin";
535 4 : goto print_remap;
536 1 : case OMP_CLAUSE_COPYPRIVATE:
537 1 : name = "copyprivate";
538 1 : goto print_remap;
539 747 : case OMP_CLAUSE_UNIFORM:
540 747 : name = "uniform";
541 747 : goto print_remap;
542 131 : case OMP_CLAUSE_USE_DEVICE_PTR:
543 131 : name = "use_device_ptr";
544 131 : if (OMP_CLAUSE_USE_DEVICE_PTR_IF_PRESENT (clause))
545 29 : modifier = "if_present:";
546 131 : goto print_remap;
547 30 : case OMP_CLAUSE_USE_DEVICE_ADDR:
548 30 : name = "use_device_addr";
549 30 : goto print_remap;
550 39 : case OMP_CLAUSE_HAS_DEVICE_ADDR:
551 39 : name = "has_device_addr";
552 39 : goto print_remap;
553 116 : case OMP_CLAUSE_IS_DEVICE_PTR:
554 116 : name = "is_device_ptr";
555 116 : goto print_remap;
556 3 : case OMP_CLAUSE_INCLUSIVE:
557 3 : name = "inclusive";
558 3 : goto print_remap;
559 2 : case OMP_CLAUSE_EXCLUSIVE:
560 2 : name = "exclusive";
561 2 : goto print_remap;
562 45 : case OMP_CLAUSE_NOVARIANTS:
563 45 : pp_string (pp, "novariants");
564 45 : pp_left_paren (pp);
565 45 : gcc_assert (OMP_CLAUSE_NOVARIANTS_EXPR (clause));
566 45 : dump_generic_node (pp, OMP_CLAUSE_NOVARIANTS_EXPR (clause), spc, flags,
567 : false);
568 45 : pp_right_paren (pp);
569 45 : break;
570 60 : case OMP_CLAUSE_NOCONTEXT:
571 60 : pp_string (pp, "nocontext");
572 60 : pp_left_paren (pp);
573 60 : gcc_assert (OMP_CLAUSE_NOCONTEXT_EXPR (clause));
574 60 : dump_generic_node (pp, OMP_CLAUSE_NOCONTEXT_EXPR (clause), spc, flags,
575 : false);
576 60 : pp_right_paren (pp);
577 60 : break;
578 86 : case OMP_CLAUSE__LOOPTEMP_:
579 86 : name = "_looptemp_";
580 86 : goto print_remap;
581 12 : case OMP_CLAUSE__REDUCTEMP_:
582 12 : name = "_reductemp_";
583 12 : goto print_remap;
584 0 : case OMP_CLAUSE__CONDTEMP_:
585 0 : name = "_condtemp_";
586 0 : goto print_remap;
587 0 : case OMP_CLAUSE__SCANTEMP_:
588 0 : name = "_scantemp_";
589 0 : goto print_remap;
590 0 : case OMP_CLAUSE_ENTER:
591 0 : if (OMP_CLAUSE_ENTER_TO (clause))
592 : name = "to";
593 : else
594 0 : name = "enter";
595 0 : goto print_remap;
596 0 : case OMP_CLAUSE_LINK:
597 0 : name = "link";
598 0 : goto print_remap;
599 3 : case OMP_CLAUSE_NONTEMPORAL:
600 3 : name = "nontemporal";
601 3 : goto print_remap;
602 8282 : print_remap:
603 8282 : pp_string (pp, name);
604 8282 : pp_left_paren (pp);
605 8282 : if (modifier)
606 36 : pp_string (pp, modifier);
607 8282 : dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
608 : spc, flags, false);
609 8282 : pp_right_paren (pp);
610 8282 : break;
611 :
612 24 : case OMP_CLAUSE_TASK_REDUCTION:
613 24 : case OMP_CLAUSE_IN_REDUCTION:
614 27 : pp_string (pp, OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_IN_REDUCTION
615 : ? "in_" : "task_");
616 : /* FALLTHRU */
617 1238 : case OMP_CLAUSE_REDUCTION:
618 1238 : pp_string (pp, "reduction(");
619 1238 : if (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_REDUCTION)
620 : {
621 1214 : if (OMP_CLAUSE_REDUCTION_TASK (clause))
622 12 : pp_string (pp, "task,");
623 1202 : else if (OMP_CLAUSE_REDUCTION_INSCAN (clause))
624 6 : pp_string (pp, "inscan,");
625 : }
626 1238 : if (OMP_CLAUSE_REDUCTION_CODE (clause) != ERROR_MARK)
627 : {
628 1227 : pp_string (pp,
629 1227 : op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause)));
630 1227 : pp_colon (pp);
631 : }
632 1238 : dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
633 : spc, flags, false);
634 1238 : pp_right_paren (pp);
635 1238 : break;
636 :
637 148 : case OMP_CLAUSE_IF:
638 148 : pp_string (pp, "if(");
639 148 : switch (OMP_CLAUSE_IF_MODIFIER (clause))
640 : {
641 : case ERROR_MARK: break;
642 0 : case VOID_CST: pp_string (pp, "cancel:"); break;
643 4 : case OMP_PARALLEL: pp_string (pp, "parallel:"); break;
644 2 : case OMP_SIMD: pp_string (pp, "simd:"); break;
645 0 : case OMP_TASK: pp_string (pp, "task:"); break;
646 4 : case OMP_TASKLOOP: pp_string (pp, "taskloop:"); break;
647 0 : case OMP_TARGET_DATA: pp_string (pp, "target data:"); break;
648 0 : case OMP_TARGET: pp_string (pp, "target:"); break;
649 0 : case OMP_TARGET_UPDATE: pp_string (pp, "target update:"); break;
650 0 : case OMP_TARGET_ENTER_DATA:
651 0 : pp_string (pp, "target enter data:"); break;
652 0 : case OMP_TARGET_EXIT_DATA: pp_string (pp, "target exit data:"); break;
653 0 : default: gcc_unreachable ();
654 : }
655 148 : dump_generic_node (pp, OMP_CLAUSE_IF_EXPR (clause),
656 : spc, flags, false);
657 148 : pp_right_paren (pp);
658 148 : break;
659 :
660 52 : case OMP_CLAUSE_DESTROY:
661 52 : pp_string (pp, "destroy(");
662 52 : dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
663 : spc, flags, false);
664 52 : pp_right_paren (pp);
665 52 : break;
666 :
667 251 : case OMP_CLAUSE_INIT:
668 251 : pp_string (pp, "init(");
669 251 : dump_omp_init_prefer_type (pp, OMP_CLAUSE_INIT_PREFER_TYPE (clause));
670 251 : if (OMP_CLAUSE_INIT_TARGET (clause))
671 : {
672 156 : if (OMP_CLAUSE_INIT_PREFER_TYPE (clause))
673 67 : pp_string (pp, ", ");
674 156 : pp_string (pp, "target");
675 : }
676 251 : if (OMP_CLAUSE_INIT_TARGETSYNC (clause))
677 : {
678 128 : if (OMP_CLAUSE_INIT_PREFER_TYPE (clause) || OMP_CLAUSE_INIT_TARGET (clause))
679 85 : pp_string (pp, ", ");
680 128 : pp_string (pp, "targetsync");
681 : }
682 251 : if (OMP_CLAUSE_INIT_PREFER_TYPE (clause)
683 132 : || OMP_CLAUSE_INIT_TARGET (clause)
684 294 : || OMP_CLAUSE_INIT_TARGETSYNC (clause))
685 251 : pp_string (pp, ": ");
686 251 : dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
687 : spc, flags, false);
688 251 : pp_right_paren (pp);
689 251 : break;
690 :
691 59 : case OMP_CLAUSE_USE:
692 59 : pp_string (pp, "use(");
693 59 : dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
694 : spc, flags, false);
695 59 : pp_right_paren (pp);
696 59 : break;
697 :
698 61 : case OMP_CLAUSE_SELF:
699 61 : pp_string (pp, "self(");
700 61 : dump_generic_node (pp, OMP_CLAUSE_SELF_EXPR (clause),
701 : spc, flags, false);
702 61 : pp_right_paren (pp);
703 61 : break;
704 :
705 141 : case OMP_CLAUSE_NUM_THREADS:
706 141 : pp_string (pp, "num_threads(");
707 141 : if (OMP_CLAUSE_NUM_THREADS_STRICT (clause))
708 9 : pp_string (pp, "strict");
709 141 : if (OMP_CLAUSE_NUM_THREADS_STRICT (clause)
710 141 : && OMP_CLAUSE_NUM_THREADS_DIMS (clause))
711 5 : pp_comma (pp);
712 141 : if (OMP_CLAUSE_NUM_THREADS_DIMS (clause))
713 11 : pp_string (pp, "dims()");
714 141 : if (OMP_CLAUSE_NUM_THREADS_STRICT (clause)
715 141 : || OMP_CLAUSE_NUM_THREADS_DIMS (clause))
716 15 : pp_colon (pp);
717 141 : dump_generic_node (pp, OMP_CLAUSE_NUM_THREADS_EXPR (clause),
718 : spc, flags, false);
719 141 : pp_right_paren (pp);
720 141 : break;
721 :
722 752 : case OMP_CLAUSE_NOWAIT:
723 752 : pp_string (pp, "nowait");
724 752 : break;
725 27 : case OMP_CLAUSE_ORDERED:
726 27 : pp_string (pp, "ordered");
727 27 : if (OMP_CLAUSE_ORDERED_EXPR (clause))
728 : {
729 9 : pp_left_paren (pp);
730 9 : dump_generic_node (pp, OMP_CLAUSE_ORDERED_EXPR (clause),
731 : spc, flags, false);
732 9 : pp_right_paren (pp);
733 : }
734 : break;
735 :
736 1258 : case OMP_CLAUSE_DEFAULT:
737 1258 : pp_string (pp, "default(");
738 1258 : switch (OMP_CLAUSE_DEFAULT_KIND (clause))
739 : {
740 : case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
741 : break;
742 11 : case OMP_CLAUSE_DEFAULT_SHARED:
743 11 : pp_string (pp, "shared");
744 11 : break;
745 1192 : case OMP_CLAUSE_DEFAULT_NONE:
746 1192 : pp_string (pp, "none");
747 1192 : break;
748 0 : case OMP_CLAUSE_DEFAULT_PRIVATE:
749 0 : pp_string (pp, "private");
750 0 : break;
751 2 : case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE:
752 2 : pp_string (pp, "firstprivate");
753 2 : break;
754 53 : case OMP_CLAUSE_DEFAULT_PRESENT:
755 53 : pp_string (pp, "present");
756 53 : break;
757 0 : default:
758 0 : gcc_unreachable ();
759 : }
760 1258 : pp_right_paren (pp);
761 1258 : break;
762 :
763 152 : case OMP_CLAUSE_SCHEDULE:
764 152 : pp_string (pp, "schedule(");
765 152 : if (OMP_CLAUSE_SCHEDULE_KIND (clause)
766 : & (OMP_CLAUSE_SCHEDULE_MONOTONIC
767 : | OMP_CLAUSE_SCHEDULE_NONMONOTONIC))
768 : {
769 0 : if (OMP_CLAUSE_SCHEDULE_KIND (clause)
770 : & OMP_CLAUSE_SCHEDULE_MONOTONIC)
771 0 : pp_string (pp, "monotonic");
772 : else
773 0 : pp_string (pp, "nonmonotonic");
774 0 : if (OMP_CLAUSE_SCHEDULE_SIMD (clause))
775 0 : pp_comma (pp);
776 : else
777 0 : pp_colon (pp);
778 : }
779 152 : if (OMP_CLAUSE_SCHEDULE_SIMD (clause))
780 0 : pp_string (pp, "simd:");
781 :
782 152 : switch (OMP_CLAUSE_SCHEDULE_KIND (clause) & OMP_CLAUSE_SCHEDULE_MASK)
783 : {
784 111 : case OMP_CLAUSE_SCHEDULE_STATIC:
785 111 : pp_string (pp, "static");
786 111 : break;
787 4 : case OMP_CLAUSE_SCHEDULE_DYNAMIC:
788 4 : pp_string (pp, "dynamic");
789 4 : break;
790 27 : case OMP_CLAUSE_SCHEDULE_GUIDED:
791 27 : pp_string (pp, "guided");
792 27 : break;
793 2 : case OMP_CLAUSE_SCHEDULE_RUNTIME:
794 2 : pp_string (pp, "runtime");
795 2 : break;
796 8 : case OMP_CLAUSE_SCHEDULE_AUTO:
797 8 : pp_string (pp, "auto");
798 8 : break;
799 0 : default:
800 0 : gcc_unreachable ();
801 : }
802 152 : if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause))
803 : {
804 16 : pp_comma (pp);
805 16 : dump_generic_node (pp, OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause),
806 : spc, flags, false);
807 : }
808 152 : pp_right_paren (pp);
809 152 : break;
810 :
811 4 : case OMP_CLAUSE_UNTIED:
812 4 : pp_string (pp, "untied");
813 4 : break;
814 :
815 418 : case OMP_CLAUSE_COLLAPSE:
816 418 : pp_string (pp, "collapse(");
817 418 : dump_generic_node (pp, OMP_CLAUSE_COLLAPSE_EXPR (clause),
818 : spc, flags, false);
819 418 : pp_right_paren (pp);
820 418 : break;
821 :
822 4 : case OMP_CLAUSE_FINAL:
823 4 : pp_string (pp, "final(");
824 4 : dump_generic_node (pp, OMP_CLAUSE_FINAL_EXPR (clause),
825 : spc, flags, false);
826 4 : pp_right_paren (pp);
827 4 : break;
828 :
829 4 : case OMP_CLAUSE_MERGEABLE:
830 4 : pp_string (pp, "mergeable");
831 4 : break;
832 :
833 19 : case OMP_CLAUSE_MESSAGE:
834 19 : if (OMP_CLAUSE_MESSAGE_EXPR (clause))
835 : {
836 17 : pp_string (pp, "message(");
837 17 : dump_generic_node (pp, OMP_CLAUSE_MESSAGE_EXPR (clause),
838 : spc, flags, false);
839 17 : if (OMP_CLAUSE_MESSAGE_LEN (clause))
840 : {
841 17 : pp_string (pp, " [len:");
842 17 : dump_generic_node (pp, OMP_CLAUSE_MESSAGE_LEN (clause),
843 : spc, flags, false);
844 17 : pp_right_bracket (pp);
845 : }
846 17 : pp_right_paren (pp);
847 17 : if (OMP_CLAUSE_MESSAGE_SEVERITY_WARN (clause))
848 8 : pp_space (pp);
849 : }
850 19 : if (OMP_CLAUSE_MESSAGE_SEVERITY_WARN (clause))
851 10 : pp_string (pp, "severity(warning)");
852 : else
853 9 : pp_string (pp, "severity(fatal)");
854 : break;
855 :
856 1870 : case OMP_CLAUSE_LINEAR:
857 1870 : pp_string (pp, "linear(");
858 1870 : if (OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER (clause))
859 4 : switch (OMP_CLAUSE_LINEAR_KIND (clause))
860 : {
861 : case OMP_CLAUSE_LINEAR_DEFAULT:
862 : break;
863 4 : case OMP_CLAUSE_LINEAR_REF:
864 4 : pp_string (pp, "ref(");
865 4 : break;
866 0 : case OMP_CLAUSE_LINEAR_VAL:
867 0 : pp_string (pp, "val(");
868 0 : break;
869 0 : case OMP_CLAUSE_LINEAR_UVAL:
870 0 : pp_string (pp, "uval(");
871 0 : break;
872 0 : default:
873 0 : gcc_unreachable ();
874 : }
875 1870 : dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
876 : spc, flags, false);
877 1870 : if (OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER (clause)
878 1870 : && OMP_CLAUSE_LINEAR_KIND (clause) != OMP_CLAUSE_LINEAR_DEFAULT)
879 4 : pp_right_paren (pp);
880 1870 : pp_colon (pp);
881 1870 : if (!OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER (clause)
882 1870 : && OMP_CLAUSE_LINEAR_KIND (clause) != OMP_CLAUSE_LINEAR_DEFAULT)
883 81 : switch (OMP_CLAUSE_LINEAR_KIND (clause))
884 : {
885 60 : case OMP_CLAUSE_LINEAR_REF:
886 60 : pp_string (pp, "ref,step(");
887 60 : break;
888 13 : case OMP_CLAUSE_LINEAR_VAL:
889 13 : pp_string (pp, "val,step(");
890 13 : break;
891 8 : case OMP_CLAUSE_LINEAR_UVAL:
892 8 : pp_string (pp, "uval,step(");
893 8 : break;
894 0 : default:
895 0 : gcc_unreachable ();
896 : }
897 1870 : dump_generic_node (pp, OMP_CLAUSE_LINEAR_STEP (clause),
898 : spc, flags, false);
899 1870 : if (!OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER (clause)
900 1870 : && OMP_CLAUSE_LINEAR_KIND (clause) != OMP_CLAUSE_LINEAR_DEFAULT)
901 81 : pp_right_paren (pp);
902 1870 : pp_right_paren (pp);
903 1870 : break;
904 :
905 338 : case OMP_CLAUSE_ALIGNED:
906 338 : pp_string (pp, "aligned(");
907 338 : dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
908 : spc, flags, false);
909 338 : if (OMP_CLAUSE_ALIGNED_ALIGNMENT (clause))
910 : {
911 338 : pp_colon (pp);
912 338 : dump_generic_node (pp, OMP_CLAUSE_ALIGNED_ALIGNMENT (clause),
913 : spc, flags, false);
914 : }
915 338 : pp_right_paren (pp);
916 338 : break;
917 :
918 89 : case OMP_CLAUSE_ALLOCATE:
919 89 : pp_string (pp, "allocate(");
920 89 : if (OMP_CLAUSE_ALLOCATE_ALLOCATOR (clause))
921 : {
922 88 : pp_string (pp, "allocator(");
923 88 : dump_generic_node (pp, OMP_CLAUSE_ALLOCATE_ALLOCATOR (clause),
924 : spc, flags, false);
925 88 : pp_right_paren (pp);
926 : }
927 89 : if (OMP_CLAUSE_ALLOCATE_ALIGN (clause))
928 : {
929 57 : if (OMP_CLAUSE_ALLOCATE_ALLOCATOR (clause))
930 56 : pp_comma (pp);
931 57 : pp_string (pp, "align(");
932 57 : dump_generic_node (pp, OMP_CLAUSE_ALLOCATE_ALIGN (clause),
933 : spc, flags, false);
934 57 : pp_right_paren (pp);
935 : }
936 89 : if (OMP_CLAUSE_ALLOCATE_ALLOCATOR (clause)
937 89 : || OMP_CLAUSE_ALLOCATE_ALIGN (clause))
938 89 : pp_colon (pp);
939 89 : dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
940 : spc, flags, false);
941 89 : pp_right_paren (pp);
942 89 : break;
943 :
944 98 : case OMP_CLAUSE_USES_ALLOCATORS:
945 98 : pp_string (pp, "uses_allocators(memspace(");
946 98 : dump_generic_node (pp, OMP_CLAUSE_USES_ALLOCATORS_MEMSPACE (clause),
947 : spc, flags, false);
948 98 : pp_string (pp, "), traits(");
949 98 : dump_generic_node (pp, OMP_CLAUSE_USES_ALLOCATORS_TRAITS (clause),
950 : spc, flags, false);
951 98 : pp_string (pp, ") : ");
952 98 : dump_generic_node (pp, OMP_CLAUSE_USES_ALLOCATORS_ALLOCATOR (clause),
953 : spc, flags, false);
954 98 : pp_right_paren (pp);
955 98 : break;
956 :
957 68 : case OMP_CLAUSE_AFFINITY:
958 68 : pp_string (pp, "affinity(");
959 68 : {
960 68 : tree t = OMP_CLAUSE_DECL (clause);
961 68 : if (OMP_ITERATOR_DECL_P (t))
962 : {
963 18 : dump_omp_iterators (pp, TREE_PURPOSE (t), spc, flags);
964 18 : pp_colon (pp);
965 18 : t = TREE_VALUE (t);
966 : }
967 68 : dump_generic_node (pp, t, spc, flags, false);
968 : }
969 68 : pp_right_paren (pp);
970 68 : break;
971 176 : case OMP_CLAUSE_DEPEND:
972 176 : pp_string (pp, "depend(");
973 176 : switch (OMP_CLAUSE_DEPEND_KIND (clause))
974 : {
975 : case OMP_CLAUSE_DEPEND_DEPOBJ:
976 : name = "depobj";
977 : break;
978 5 : case OMP_CLAUSE_DEPEND_IN:
979 5 : name = "in";
980 5 : break;
981 123 : case OMP_CLAUSE_DEPEND_OUT:
982 123 : name = "out";
983 123 : break;
984 28 : case OMP_CLAUSE_DEPEND_INOUT:
985 28 : name = "inout";
986 28 : break;
987 0 : case OMP_CLAUSE_DEPEND_MUTEXINOUTSET:
988 0 : name = "mutexinoutset";
989 0 : break;
990 0 : case OMP_CLAUSE_DEPEND_INOUTSET:
991 0 : name = "inoutset";
992 0 : break;
993 0 : case OMP_CLAUSE_DEPEND_LAST:
994 0 : name = "__internal__";
995 0 : break;
996 0 : default:
997 0 : gcc_unreachable ();
998 : }
999 176 : {
1000 176 : tree t = OMP_CLAUSE_DECL (clause);
1001 176 : if (OMP_ITERATOR_DECL_P (t))
1002 : {
1003 0 : dump_omp_iterators (pp, TREE_PURPOSE (t), spc, flags);
1004 0 : pp_colon (pp);
1005 0 : t = TREE_VALUE (t);
1006 : }
1007 176 : if (name[0])
1008 : {
1009 176 : pp_string (pp, name);
1010 176 : pp_colon (pp);
1011 : }
1012 176 : if (t == null_pointer_node)
1013 0 : pp_string (pp, "omp_all_memory");
1014 : else
1015 176 : dump_generic_node (pp, t, spc, flags, false);
1016 176 : pp_right_paren (pp);
1017 : }
1018 176 : break;
1019 :
1020 22 : case OMP_CLAUSE_DOACROSS:
1021 22 : pp_string (pp, OMP_CLAUSE_DOACROSS_DEPEND (clause)
1022 : ? "depend(" : "doacross(");
1023 22 : switch (OMP_CLAUSE_DOACROSS_KIND (clause))
1024 : {
1025 9 : case OMP_CLAUSE_DOACROSS_SOURCE:
1026 9 : if (OMP_CLAUSE_DOACROSS_DEPEND (clause))
1027 9 : pp_string (pp, "source)");
1028 : else
1029 0 : pp_string (pp, "source:)");
1030 : break;
1031 13 : case OMP_CLAUSE_DOACROSS_SINK:
1032 13 : pp_string (pp, "sink:");
1033 13 : if (OMP_CLAUSE_DECL (clause) == NULL_TREE)
1034 : {
1035 0 : pp_string (pp, "omp_cur_iteration-1)");
1036 0 : break;
1037 : }
1038 34 : for (tree t = OMP_CLAUSE_DECL (clause); t; t = TREE_CHAIN (t))
1039 21 : if (TREE_CODE (t) == TREE_LIST)
1040 : {
1041 21 : dump_generic_node (pp, TREE_VALUE (t), spc, flags, false);
1042 21 : if (TREE_PURPOSE (t) != integer_zero_node)
1043 : {
1044 19 : if (OMP_CLAUSE_DOACROSS_SINK_NEGATIVE (t))
1045 8 : pp_minus (pp);
1046 : else
1047 11 : pp_plus (pp);
1048 19 : dump_generic_node (pp, TREE_PURPOSE (t), spc, flags,
1049 : false);
1050 : }
1051 21 : if (TREE_CHAIN (t))
1052 8 : pp_comma (pp);
1053 : }
1054 : else
1055 0 : gcc_unreachable ();
1056 13 : pp_right_paren (pp);
1057 13 : break;
1058 0 : default:
1059 0 : gcc_unreachable ();
1060 : }
1061 : break;
1062 :
1063 6471 : case OMP_CLAUSE_MAP:
1064 6471 : pp_string (pp, "map(");
1065 6471 : if (OMP_CLAUSE_MAP_READONLY (clause))
1066 70 : pp_string (pp, "readonly,");
1067 6471 : if (OMP_CLAUSE_ITERATORS (clause))
1068 : {
1069 84 : dump_omp_iterators (pp, OMP_CLAUSE_ITERATORS (clause), spc, flags);
1070 84 : pp_colon (pp);
1071 : }
1072 6471 : switch (OMP_CLAUSE_MAP_KIND (clause))
1073 : {
1074 1007 : case GOMP_MAP_ALLOC:
1075 1007 : case GOMP_MAP_POINTER:
1076 1007 : case GOMP_MAP_POINTER_TO_ZERO_LENGTH_ARRAY_SECTION:
1077 1007 : pp_string (pp, "alloc");
1078 1007 : break;
1079 4 : case GOMP_MAP_IF_PRESENT:
1080 4 : pp_string (pp, "no_alloc");
1081 4 : break;
1082 807 : case GOMP_MAP_TO:
1083 807 : case GOMP_MAP_TO_PSET:
1084 807 : pp_string (pp, "to");
1085 807 : break;
1086 601 : case GOMP_MAP_FROM:
1087 601 : pp_string (pp, "from");
1088 601 : break;
1089 2223 : case GOMP_MAP_TOFROM:
1090 2223 : pp_string (pp, "tofrom");
1091 2223 : break;
1092 3 : case GOMP_MAP_FORCE_ALLOC:
1093 3 : pp_string (pp, "force_alloc");
1094 3 : break;
1095 17 : case GOMP_MAP_FORCE_TO:
1096 17 : pp_string (pp, "force_to");
1097 17 : break;
1098 26 : case GOMP_MAP_FORCE_FROM:
1099 26 : pp_string (pp, "force_from");
1100 26 : break;
1101 61 : case GOMP_MAP_FORCE_TOFROM:
1102 61 : pp_string (pp, "force_tofrom");
1103 61 : break;
1104 229 : case GOMP_MAP_FORCE_PRESENT:
1105 229 : pp_string (pp, "force_present");
1106 229 : break;
1107 83 : case GOMP_MAP_DELETE:
1108 83 : pp_string (pp, "delete");
1109 83 : break;
1110 8 : case GOMP_MAP_FORCE_DEVICEPTR:
1111 8 : pp_string (pp, "force_deviceptr");
1112 8 : break;
1113 158 : case GOMP_MAP_ALWAYS_TO:
1114 158 : pp_string (pp, "always,to");
1115 158 : break;
1116 40 : case GOMP_MAP_ALWAYS_FROM:
1117 40 : pp_string (pp, "always,from");
1118 40 : break;
1119 14 : case GOMP_MAP_ALWAYS_TOFROM:
1120 14 : pp_string (pp, "always,tofrom");
1121 14 : break;
1122 190 : case GOMP_MAP_RELEASE:
1123 190 : pp_string (pp, "release");
1124 190 : break;
1125 344 : case GOMP_MAP_FIRSTPRIVATE_POINTER:
1126 344 : pp_string (pp, "firstprivate");
1127 344 : break;
1128 0 : case GOMP_MAP_FIRSTPRIVATE_REFERENCE:
1129 0 : pp_string (pp, "firstprivate ref");
1130 0 : break;
1131 150 : case GOMP_MAP_STRUCT:
1132 150 : pp_string (pp, "struct");
1133 150 : break;
1134 2 : case GOMP_MAP_STRUCT_UNORD:
1135 2 : pp_string (pp, "struct_unord");
1136 2 : break;
1137 51 : case GOMP_MAP_ALWAYS_POINTER:
1138 51 : pp_string (pp, "always_pointer");
1139 51 : break;
1140 0 : case GOMP_MAP_DEVICE_RESIDENT:
1141 0 : pp_string (pp, "device_resident");
1142 0 : break;
1143 0 : case GOMP_MAP_LINK:
1144 0 : pp_string (pp, "link");
1145 0 : break;
1146 162 : case GOMP_MAP_ATTACH:
1147 162 : pp_string (pp, "attach");
1148 162 : break;
1149 42 : case GOMP_MAP_DETACH:
1150 42 : pp_string (pp, "detach");
1151 42 : break;
1152 8 : case GOMP_MAP_FORCE_DETACH:
1153 8 : pp_string (pp, "force_detach");
1154 8 : break;
1155 46 : case GOMP_MAP_ATTACH_DETACH:
1156 46 : pp_string (pp, "attach_detach");
1157 46 : break;
1158 8 : case GOMP_MAP_ATTACH_ZERO_LENGTH_ARRAY_SECTION:
1159 8 : pp_string (pp, "attach_zero_length_array_section");
1160 8 : break;
1161 29 : case GOMP_MAP_PRESENT_ALLOC:
1162 29 : pp_string (pp, "present,alloc");
1163 29 : break;
1164 29 : case GOMP_MAP_PRESENT_TO:
1165 29 : pp_string (pp, "present,to");
1166 29 : break;
1167 16 : case GOMP_MAP_PRESENT_FROM:
1168 16 : pp_string (pp, "present,from");
1169 16 : break;
1170 15 : case GOMP_MAP_PRESENT_TOFROM:
1171 15 : pp_string (pp, "present,tofrom");
1172 15 : break;
1173 40 : case GOMP_MAP_ALWAYS_PRESENT_TO:
1174 40 : pp_string (pp, "always,present,to");
1175 40 : break;
1176 30 : case GOMP_MAP_ALWAYS_PRESENT_FROM:
1177 30 : pp_string (pp, "always,present,from");
1178 30 : break;
1179 12 : case GOMP_MAP_ALWAYS_PRESENT_TOFROM:
1180 12 : pp_string (pp, "always,present,tofrom");
1181 12 : break;
1182 16 : case GOMP_MAP_UNSET:
1183 16 : pp_string (pp, "unset");
1184 16 : break;
1185 0 : case GOMP_MAP_PUSH_MAPPER_NAME:
1186 0 : pp_string (pp, "push_mapper");
1187 0 : break;
1188 0 : case GOMP_MAP_POP_MAPPER_NAME:
1189 0 : pp_string (pp, "pop_mapper");
1190 0 : break;
1191 0 : case GOMP_MAP_USES_ALLOCATORS:
1192 0 : pp_string (pp, "uses_allocators");
1193 0 : break;
1194 0 : default:
1195 0 : gcc_unreachable ();
1196 : }
1197 6471 : pp_colon (pp);
1198 6471 : dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
1199 : spc, flags, false);
1200 6728 : print_clause_size:
1201 6728 : if (OMP_CLAUSE_SIZE (clause))
1202 : {
1203 11297 : switch (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_MAP
1204 5719 : ? OMP_CLAUSE_MAP_KIND (clause) : GOMP_MAP_TO)
1205 : {
1206 980 : case GOMP_MAP_POINTER:
1207 980 : case GOMP_MAP_FIRSTPRIVATE_POINTER:
1208 980 : case GOMP_MAP_FIRSTPRIVATE_REFERENCE:
1209 980 : case GOMP_MAP_ALWAYS_POINTER:
1210 980 : pp_string (pp, " [pointer assign, bias: ");
1211 980 : break;
1212 4 : case GOMP_MAP_POINTER_TO_ZERO_LENGTH_ARRAY_SECTION:
1213 4 : pp_string (pp, " [pointer assign, zero-length array section, bias: ");
1214 4 : break;
1215 141 : case GOMP_MAP_TO_PSET:
1216 141 : pp_string (pp, " [pointer set, len: ");
1217 141 : break;
1218 266 : case GOMP_MAP_ATTACH:
1219 266 : case GOMP_MAP_DETACH:
1220 266 : case GOMP_MAP_FORCE_DETACH:
1221 266 : case GOMP_MAP_ATTACH_DETACH:
1222 266 : case GOMP_MAP_ATTACH_ZERO_LENGTH_ARRAY_SECTION:
1223 266 : pp_string (pp, " [bias: ");
1224 266 : break;
1225 179 : case GOMP_MAP_RELEASE:
1226 179 : case GOMP_MAP_DELETE:
1227 179 : if (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_MAP
1228 179 : && OMP_CLAUSE_RELEASE_DESCRIPTOR (clause))
1229 : {
1230 25 : pp_string (pp, " [pointer set, len: ");
1231 25 : break;
1232 : }
1233 : /* Fallthrough. */
1234 4303 : default:
1235 4303 : pp_string (pp, " [len: ");
1236 4303 : break;
1237 : }
1238 5719 : dump_generic_node (pp, OMP_CLAUSE_SIZE (clause),
1239 : spc, flags, false);
1240 5719 : if (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_MAP
1241 5719 : && OMP_CLAUSE_MAP_SIZE_NEEDS_ADJUSTMENT (clause))
1242 2 : pp_string (pp, " (needs adjustment)");
1243 5719 : pp_right_bracket (pp);
1244 : }
1245 6728 : if (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_MAP)
1246 : {
1247 6471 : if (OMP_CLAUSE_MAP_RUNTIME_IMPLICIT_P (clause))
1248 833 : pp_string (pp, " [runtime_implicit]");
1249 6471 : if (OMP_CLAUSE_MAP_GIMPLE_ONLY (clause))
1250 1 : pp_string (pp, " [gimple only]");
1251 : }
1252 6728 : pp_right_paren (pp);
1253 6728 : break;
1254 :
1255 90 : case OMP_CLAUSE_FROM:
1256 90 : pp_string (pp, "from(");
1257 90 : if (OMP_CLAUSE_MOTION_PRESENT (clause))
1258 37 : pp_string (pp, "present:");
1259 90 : if (OMP_CLAUSE_ITERATORS (clause))
1260 : {
1261 10 : dump_omp_iterators (pp, OMP_CLAUSE_ITERATORS (clause), spc, flags);
1262 10 : pp_colon (pp);
1263 : }
1264 90 : dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
1265 : spc, flags, false);
1266 90 : goto print_clause_size;
1267 :
1268 111 : case OMP_CLAUSE_TO:
1269 111 : pp_string (pp, "to(");
1270 111 : if (OMP_CLAUSE_MOTION_PRESENT (clause))
1271 37 : pp_string (pp, "present:");
1272 111 : if (OMP_CLAUSE_ITERATORS (clause))
1273 : {
1274 25 : dump_omp_iterators (pp, OMP_CLAUSE_ITERATORS (clause), spc, flags);
1275 25 : pp_colon (pp);
1276 : }
1277 111 : dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
1278 : spc, flags, false);
1279 111 : goto print_clause_size;
1280 :
1281 56 : case OMP_CLAUSE__CACHE_:
1282 56 : pp_string (pp, "(");
1283 56 : if (OMP_CLAUSE__CACHE__READONLY (clause))
1284 32 : pp_string (pp, "readonly:");
1285 56 : dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
1286 : spc, flags, false);
1287 56 : goto print_clause_size;
1288 :
1289 24 : case OMP_CLAUSE__MAPPER_BINDING_:
1290 24 : pp_string (pp, "mapper_binding(");
1291 24 : if (OMP_CLAUSE__MAPPER_BINDING__ID (clause))
1292 : {
1293 0 : dump_generic_node (pp, OMP_CLAUSE__MAPPER_BINDING__ID (clause), spc,
1294 : flags, false);
1295 0 : pp_comma (pp);
1296 : }
1297 24 : dump_generic_node (pp,
1298 24 : TREE_TYPE (OMP_CLAUSE__MAPPER_BINDING__DECL (clause)),
1299 : spc, flags, false);
1300 24 : pp_comma (pp);
1301 24 : dump_generic_node (pp, OMP_CLAUSE__MAPPER_BINDING__MAPPER (clause), spc,
1302 : flags, false);
1303 24 : pp_right_paren (pp);
1304 24 : break;
1305 :
1306 1190 : case OMP_CLAUSE_NUM_TEAMS:
1307 1190 : pp_string (pp, "num_teams(");
1308 1190 : if (OMP_CLAUSE_NUM_TEAMS_DIMS (clause))
1309 13 : pp_string (pp, "dims():");
1310 1190 : if (OMP_CLAUSE_NUM_TEAMS_LOWER_EXPR (clause))
1311 : {
1312 0 : dump_generic_node (pp, OMP_CLAUSE_NUM_TEAMS_LOWER_EXPR (clause),
1313 : spc, flags, false);
1314 0 : pp_colon (pp);
1315 : }
1316 1190 : dump_generic_node (pp, OMP_CLAUSE_NUM_TEAMS_UPPER_EXPR (clause),
1317 : spc, flags, false);
1318 1190 : pp_right_paren (pp);
1319 1190 : break;
1320 :
1321 1202 : case OMP_CLAUSE_THREAD_LIMIT:
1322 1202 : pp_string (pp, "thread_limit(");
1323 1202 : if (OMP_CLAUSE_THREAD_LIMIT_STRICT (clause))
1324 10 : pp_string (pp, "strict");
1325 1202 : if (OMP_CLAUSE_THREAD_LIMIT_STRICT (clause)
1326 1202 : && OMP_CLAUSE_THREAD_LIMIT_DIMS (clause))
1327 7 : pp_comma (pp);
1328 1202 : if (OMP_CLAUSE_THREAD_LIMIT_DIMS (clause))
1329 11 : pp_string (pp, "dims()");
1330 1202 : if (OMP_CLAUSE_THREAD_LIMIT_STRICT (clause)
1331 1202 : || OMP_CLAUSE_THREAD_LIMIT_DIMS (clause))
1332 14 : pp_colon (pp);
1333 1202 : dump_generic_node (pp, OMP_CLAUSE_THREAD_LIMIT_EXPR (clause),
1334 : spc, flags, false);
1335 1202 : pp_right_paren (pp);
1336 1202 : break;
1337 :
1338 66 : case OMP_CLAUSE_DEVICE:
1339 66 : pp_string (pp, "device(");
1340 66 : if (OMP_CLAUSE_DEVICE_ANCESTOR (clause))
1341 13 : pp_string (pp, "ancestor:");
1342 66 : dump_generic_node (pp, OMP_CLAUSE_DEVICE_ID (clause),
1343 : spc, flags, false);
1344 66 : pp_right_paren (pp);
1345 66 : break;
1346 :
1347 0 : case OMP_CLAUSE_DIST_SCHEDULE:
1348 0 : pp_string (pp, "dist_schedule(static");
1349 0 : if (OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause))
1350 : {
1351 0 : pp_comma (pp);
1352 0 : dump_generic_node (pp,
1353 0 : OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause),
1354 : spc, flags, false);
1355 : }
1356 0 : pp_right_paren (pp);
1357 0 : break;
1358 :
1359 4 : case OMP_CLAUSE_PROC_BIND:
1360 4 : pp_string (pp, "proc_bind(");
1361 4 : switch (OMP_CLAUSE_PROC_BIND_KIND (clause))
1362 : {
1363 0 : case OMP_CLAUSE_PROC_BIND_MASTER:
1364 : /* Same enum value: case OMP_CLAUSE_PROC_BIND_PRIMARY: */
1365 : /* TODO: Change to 'primary' for OpenMP 5.1. */
1366 0 : pp_string (pp, "master");
1367 0 : break;
1368 0 : case OMP_CLAUSE_PROC_BIND_CLOSE:
1369 0 : pp_string (pp, "close");
1370 0 : break;
1371 4 : case OMP_CLAUSE_PROC_BIND_SPREAD:
1372 4 : pp_string (pp, "spread");
1373 4 : break;
1374 0 : default:
1375 0 : gcc_unreachable ();
1376 : }
1377 4 : pp_right_paren (pp);
1378 4 : break;
1379 :
1380 31 : case OMP_CLAUSE_DEVICE_TYPE:
1381 31 : pp_string (pp, "device_type(");
1382 31 : switch (OMP_CLAUSE_DEVICE_TYPE_KIND (clause))
1383 : {
1384 7 : case OMP_CLAUSE_DEVICE_TYPE_HOST:
1385 7 : pp_string (pp, "host");
1386 7 : break;
1387 8 : case OMP_CLAUSE_DEVICE_TYPE_NOHOST:
1388 8 : pp_string (pp, "nohost");
1389 8 : break;
1390 16 : case OMP_CLAUSE_DEVICE_TYPE_ANY:
1391 16 : pp_string (pp, "any");
1392 16 : break;
1393 0 : default:
1394 0 : gcc_unreachable ();
1395 : }
1396 31 : pp_right_paren (pp);
1397 31 : break;
1398 :
1399 25 : case OMP_CLAUSE_DYN_GROUPPRIVATE:
1400 25 : pp_string (pp, "dyn_groupprivate(");
1401 25 : switch (OMP_CLAUSE_DYN_GROUPPRIVATE_KIND (clause))
1402 : {
1403 5 : case OMP_CLAUSE_FALLBACK_ABORT:
1404 5 : pp_string (pp, "fallback(abort):");
1405 5 : break;
1406 5 : case OMP_CLAUSE_FALLBACK_DEFAULT_MEM:
1407 5 : pp_string (pp, "fallback(default_mem):");
1408 5 : break;
1409 5 : case OMP_CLAUSE_FALLBACK_NULL:
1410 5 : pp_string (pp, "fallback(null):");
1411 5 : break;
1412 : case OMP_CLAUSE_FALLBACK_UNSPECIFIED:
1413 : break;
1414 : }
1415 25 : dump_generic_node (pp, OMP_CLAUSE_DYN_GROUPPRIVATE_EXPR (clause),
1416 : spc, flags, false);
1417 25 : pp_right_paren (pp);
1418 25 : break;
1419 :
1420 23 : case OMP_CLAUSE_SAFELEN:
1421 23 : pp_string (pp, "safelen(");
1422 23 : dump_generic_node (pp, OMP_CLAUSE_SAFELEN_EXPR (clause),
1423 : spc, flags, false);
1424 23 : pp_right_paren (pp);
1425 23 : break;
1426 :
1427 424 : case OMP_CLAUSE_SIMDLEN:
1428 424 : pp_string (pp, "simdlen(");
1429 424 : dump_generic_node (pp, OMP_CLAUSE_SIMDLEN_EXPR (clause),
1430 : spc, flags, false);
1431 424 : pp_right_paren (pp);
1432 424 : break;
1433 :
1434 4 : case OMP_CLAUSE_PRIORITY:
1435 4 : pp_string (pp, "priority(");
1436 4 : dump_generic_node (pp, OMP_CLAUSE_PRIORITY_EXPR (clause),
1437 : spc, flags, false);
1438 4 : pp_right_paren (pp);
1439 4 : break;
1440 :
1441 10 : case OMP_CLAUSE_GRAINSIZE:
1442 10 : pp_string (pp, "grainsize(");
1443 10 : if (OMP_CLAUSE_GRAINSIZE_STRICT (clause))
1444 0 : pp_string (pp, "strict:");
1445 10 : dump_generic_node (pp, OMP_CLAUSE_GRAINSIZE_EXPR (clause),
1446 : spc, flags, false);
1447 10 : pp_right_paren (pp);
1448 10 : break;
1449 :
1450 0 : case OMP_CLAUSE_NUM_TASKS:
1451 0 : pp_string (pp, "num_tasks(");
1452 0 : if (OMP_CLAUSE_NUM_TASKS_STRICT (clause))
1453 0 : pp_string (pp, "strict:");
1454 0 : dump_generic_node (pp, OMP_CLAUSE_NUM_TASKS_EXPR (clause),
1455 : spc, flags, false);
1456 0 : pp_right_paren (pp);
1457 0 : break;
1458 :
1459 24 : case OMP_CLAUSE_HINT:
1460 24 : pp_string (pp, "hint(");
1461 24 : dump_generic_node (pp, OMP_CLAUSE_HINT_EXPR (clause),
1462 : spc, flags, false);
1463 24 : pp_right_paren (pp);
1464 24 : break;
1465 :
1466 43 : case OMP_CLAUSE_FILTER:
1467 43 : pp_string (pp, "filter(");
1468 43 : dump_generic_node (pp, OMP_CLAUSE_FILTER_EXPR (clause),
1469 : spc, flags, false);
1470 43 : pp_right_paren (pp);
1471 43 : break;
1472 :
1473 582 : case OMP_CLAUSE_DEFAULTMAP:
1474 582 : pp_string (pp, "defaultmap(");
1475 582 : switch (OMP_CLAUSE_DEFAULTMAP_BEHAVIOR (clause))
1476 : {
1477 12 : case OMP_CLAUSE_DEFAULTMAP_ALLOC:
1478 12 : pp_string (pp, "alloc");
1479 12 : break;
1480 13 : case OMP_CLAUSE_DEFAULTMAP_TO:
1481 13 : pp_string (pp, "to");
1482 13 : break;
1483 4 : case OMP_CLAUSE_DEFAULTMAP_FROM:
1484 4 : pp_string (pp, "from");
1485 4 : break;
1486 37 : case OMP_CLAUSE_DEFAULTMAP_TOFROM:
1487 37 : pp_string (pp, "tofrom");
1488 37 : break;
1489 53 : case OMP_CLAUSE_DEFAULTMAP_FIRSTPRIVATE:
1490 53 : pp_string (pp, "firstprivate");
1491 53 : break;
1492 438 : case OMP_CLAUSE_DEFAULTMAP_NONE:
1493 438 : pp_string (pp, "none");
1494 438 : break;
1495 11 : case OMP_CLAUSE_DEFAULTMAP_PRESENT:
1496 11 : pp_string (pp, "present");
1497 11 : break;
1498 14 : case OMP_CLAUSE_DEFAULTMAP_DEFAULT:
1499 14 : pp_string (pp, "default");
1500 14 : break;
1501 0 : default:
1502 0 : gcc_unreachable ();
1503 : }
1504 582 : switch (OMP_CLAUSE_DEFAULTMAP_CATEGORY (clause))
1505 : {
1506 : case OMP_CLAUSE_DEFAULTMAP_CATEGORY_UNSPECIFIED:
1507 : break;
1508 20 : case OMP_CLAUSE_DEFAULTMAP_CATEGORY_ALL:
1509 20 : pp_string (pp, ":all");
1510 20 : break;
1511 41 : case OMP_CLAUSE_DEFAULTMAP_CATEGORY_SCALAR:
1512 41 : pp_string (pp, ":scalar");
1513 41 : break;
1514 46 : case OMP_CLAUSE_DEFAULTMAP_CATEGORY_AGGREGATE:
1515 46 : pp_string (pp, ":aggregate");
1516 46 : break;
1517 12 : case OMP_CLAUSE_DEFAULTMAP_CATEGORY_ALLOCATABLE:
1518 12 : pp_string (pp, ":allocatable");
1519 12 : break;
1520 30 : case OMP_CLAUSE_DEFAULTMAP_CATEGORY_POINTER:
1521 30 : pp_string (pp, ":pointer");
1522 30 : break;
1523 0 : default:
1524 0 : gcc_unreachable ();
1525 : }
1526 582 : pp_right_paren (pp);
1527 582 : break;
1528 :
1529 302 : case OMP_CLAUSE_ORDER:
1530 302 : pp_string (pp, "order(");
1531 302 : if (OMP_CLAUSE_ORDER_UNCONSTRAINED (clause))
1532 20 : pp_string (pp, "unconstrained:");
1533 282 : else if (OMP_CLAUSE_ORDER_REPRODUCIBLE (clause))
1534 20 : pp_string (pp, "reproducible:");
1535 302 : pp_string (pp, "concurrent)");
1536 302 : break;
1537 :
1538 260 : case OMP_CLAUSE_BIND:
1539 260 : pp_string (pp, "bind(");
1540 260 : switch (OMP_CLAUSE_BIND_KIND (clause))
1541 : {
1542 143 : case OMP_CLAUSE_BIND_TEAMS:
1543 143 : pp_string (pp, "teams");
1544 143 : break;
1545 97 : case OMP_CLAUSE_BIND_PARALLEL:
1546 97 : pp_string (pp, "parallel");
1547 97 : break;
1548 20 : case OMP_CLAUSE_BIND_THREAD:
1549 20 : pp_string (pp, "thread");
1550 20 : break;
1551 0 : default:
1552 0 : gcc_unreachable ();
1553 : }
1554 260 : pp_right_paren (pp);
1555 260 : break;
1556 :
1557 8 : case OMP_CLAUSE__SIMDUID_:
1558 8 : pp_string (pp, "_simduid_(");
1559 8 : dump_generic_node (pp, OMP_CLAUSE__SIMDUID__DECL (clause),
1560 : spc, flags, false);
1561 8 : pp_right_paren (pp);
1562 8 : break;
1563 :
1564 0 : case OMP_CLAUSE__SIMT_:
1565 0 : pp_string (pp, "_simt_");
1566 0 : break;
1567 :
1568 349 : case OMP_CLAUSE_GANG:
1569 349 : pp_string (pp, "gang");
1570 349 : if (OMP_CLAUSE_GANG_EXPR (clause) != NULL_TREE)
1571 : {
1572 64 : pp_string (pp, "(num: ");
1573 64 : dump_generic_node (pp, OMP_CLAUSE_GANG_EXPR (clause),
1574 : spc, flags, false);
1575 : }
1576 349 : if (OMP_CLAUSE_GANG_STATIC_EXPR (clause) != NULL_TREE)
1577 : {
1578 12 : if (OMP_CLAUSE_GANG_EXPR (clause) == NULL_TREE)
1579 10 : pp_left_paren (pp);
1580 : else
1581 2 : pp_space (pp);
1582 12 : pp_string (pp, "static:");
1583 12 : if (OMP_CLAUSE_GANG_STATIC_EXPR (clause)
1584 12 : == integer_minus_one_node)
1585 3 : pp_character (pp, '*');
1586 : else
1587 9 : dump_generic_node (pp, OMP_CLAUSE_GANG_STATIC_EXPR (clause),
1588 : spc, flags, false);
1589 : }
1590 349 : if (OMP_CLAUSE_GANG_EXPR (clause) != NULL_TREE
1591 349 : || OMP_CLAUSE_GANG_STATIC_EXPR (clause) != NULL_TREE)
1592 74 : pp_right_paren (pp);
1593 : break;
1594 :
1595 97 : case OMP_CLAUSE_ASYNC:
1596 97 : pp_string (pp, "async");
1597 97 : if (OMP_CLAUSE_ASYNC_EXPR (clause))
1598 : {
1599 97 : pp_character(pp, '(');
1600 97 : dump_generic_node (pp, OMP_CLAUSE_ASYNC_EXPR (clause),
1601 : spc, flags, false);
1602 97 : pp_character(pp, ')');
1603 : }
1604 : break;
1605 :
1606 58 : case OMP_CLAUSE_AUTO:
1607 58 : case OMP_CLAUSE_SEQ:
1608 58 : pp_string (pp, omp_clause_code_name[OMP_CLAUSE_CODE (clause)]);
1609 58 : break;
1610 :
1611 100 : case OMP_CLAUSE_WAIT:
1612 100 : pp_string (pp, "wait(");
1613 100 : dump_generic_node (pp, OMP_CLAUSE_WAIT_EXPR (clause),
1614 : spc, flags, false);
1615 100 : pp_character(pp, ')');
1616 100 : break;
1617 :
1618 192 : case OMP_CLAUSE_WORKER:
1619 192 : pp_string (pp, "worker");
1620 192 : if (OMP_CLAUSE_WORKER_EXPR (clause) != NULL_TREE)
1621 : {
1622 62 : pp_left_paren (pp);
1623 62 : dump_generic_node (pp, OMP_CLAUSE_WORKER_EXPR (clause),
1624 : spc, flags, false);
1625 62 : pp_right_paren (pp);
1626 : }
1627 : break;
1628 :
1629 179 : case OMP_CLAUSE_VECTOR:
1630 179 : pp_string (pp, "vector");
1631 179 : if (OMP_CLAUSE_VECTOR_EXPR (clause) != NULL_TREE)
1632 : {
1633 62 : pp_left_paren (pp);
1634 62 : dump_generic_node (pp, OMP_CLAUSE_VECTOR_EXPR (clause),
1635 : spc, flags, false);
1636 62 : pp_right_paren (pp);
1637 : }
1638 : break;
1639 :
1640 25 : case OMP_CLAUSE_NUM_GANGS:
1641 25 : pp_string (pp, "num_gangs(");
1642 25 : dump_generic_node (pp, OMP_CLAUSE_NUM_GANGS_EXPR (clause),
1643 : spc, flags, false);
1644 25 : pp_character (pp, ')');
1645 25 : break;
1646 :
1647 2 : case OMP_CLAUSE_NUM_WORKERS:
1648 2 : pp_string (pp, "num_workers(");
1649 2 : dump_generic_node (pp, OMP_CLAUSE_NUM_WORKERS_EXPR (clause),
1650 : spc, flags, false);
1651 2 : pp_character (pp, ')');
1652 2 : break;
1653 :
1654 2 : case OMP_CLAUSE_VECTOR_LENGTH:
1655 2 : pp_string (pp, "vector_length(");
1656 2 : dump_generic_node (pp, OMP_CLAUSE_VECTOR_LENGTH_EXPR (clause),
1657 : spc, flags, false);
1658 2 : pp_character (pp, ')');
1659 2 : break;
1660 :
1661 166 : case OMP_CLAUSE_INBRANCH:
1662 166 : pp_string (pp, "inbranch");
1663 166 : break;
1664 925 : case OMP_CLAUSE_NOTINBRANCH:
1665 925 : pp_string (pp, "notinbranch");
1666 925 : break;
1667 0 : case OMP_CLAUSE_FOR:
1668 0 : pp_string (pp, "for");
1669 0 : break;
1670 0 : case OMP_CLAUSE_PARALLEL:
1671 0 : pp_string (pp, "parallel");
1672 0 : break;
1673 0 : case OMP_CLAUSE_SECTIONS:
1674 0 : pp_string (pp, "sections");
1675 0 : break;
1676 0 : case OMP_CLAUSE_TASKGROUP:
1677 0 : pp_string (pp, "taskgroup");
1678 0 : break;
1679 0 : case OMP_CLAUSE_NOGROUP:
1680 0 : pp_string (pp, "nogroup");
1681 0 : break;
1682 0 : case OMP_CLAUSE_THREADS:
1683 0 : pp_string (pp, "threads");
1684 0 : break;
1685 10 : case OMP_CLAUSE_SIMD:
1686 10 : pp_string (pp, "simd");
1687 10 : break;
1688 431 : case OMP_CLAUSE_INDEPENDENT:
1689 431 : pp_string (pp, "independent");
1690 431 : break;
1691 55 : case OMP_CLAUSE_TILE:
1692 55 : pp_string (pp, "tile(");
1693 55 : dump_generic_node (pp, OMP_CLAUSE_TILE_LIST (clause),
1694 : spc, flags, false);
1695 55 : pp_right_paren (pp);
1696 55 : break;
1697 135 : case OMP_CLAUSE_PARTIAL:
1698 135 : pp_string (pp, "partial");
1699 135 : if (OMP_CLAUSE_PARTIAL_EXPR (clause))
1700 : {
1701 130 : pp_left_paren (pp);
1702 130 : dump_generic_node (pp, OMP_CLAUSE_PARTIAL_EXPR (clause),
1703 : spc, flags, false);
1704 130 : pp_right_paren (pp);
1705 : }
1706 : break;
1707 55 : case OMP_CLAUSE_FULL:
1708 55 : pp_string (pp, "full");
1709 55 : break;
1710 188 : case OMP_CLAUSE_SIZES:
1711 188 : pp_string (pp, "sizes(");
1712 188 : dump_generic_node (pp, OMP_CLAUSE_SIZES_LIST (clause),
1713 : spc, flags, false);
1714 188 : pp_right_paren (pp);
1715 188 : break;
1716 351 : case OMP_CLAUSE_INTEROP:
1717 351 : pp_string (pp, "interop(");
1718 351 : dump_generic_node (pp, OMP_CLAUSE_DECL (clause), spc, flags, false);
1719 351 : pp_right_paren (pp);
1720 351 : break;
1721 58 : case OMP_CLAUSE_IF_PRESENT:
1722 58 : pp_string (pp, "if_present");
1723 58 : break;
1724 50 : case OMP_CLAUSE_FINALIZE:
1725 50 : pp_string (pp, "finalize");
1726 50 : break;
1727 5 : case OMP_CLAUSE_NOHOST:
1728 5 : pp_string (pp, "nohost");
1729 5 : break;
1730 0 : case OMP_CLAUSE_DETACH:
1731 0 : pp_string (pp, "detach(");
1732 0 : dump_generic_node (pp, OMP_CLAUSE_DECL (clause), spc, flags,
1733 : false);
1734 0 : pp_right_paren (pp);
1735 0 : break;
1736 0 : default:
1737 0 : gcc_unreachable ();
1738 : }
1739 30019 : }
1740 :
1741 :
1742 : /* Dump chain of OMP clauses.
1743 :
1744 : PP, SPC and FLAGS are as in dump_generic_node. */
1745 :
1746 : void
1747 12998 : dump_omp_clauses (pretty_printer *pp, tree clause, int spc, dump_flags_t flags,
1748 : bool leading_space)
1749 : {
1750 43017 : while (clause)
1751 : {
1752 30019 : if (leading_space)
1753 28456 : pp_space (pp);
1754 30019 : dump_omp_clause (pp, clause, spc, flags);
1755 30019 : leading_space = true;
1756 :
1757 30019 : clause = OMP_CLAUSE_CHAIN (clause);
1758 : }
1759 12998 : }
1760 :
1761 : /* Dump an OpenMP context selector CTX to PP. */
1762 : static void
1763 408 : dump_omp_context_selector (pretty_printer *pp, tree ctx, int spc,
1764 : dump_flags_t flags)
1765 : {
1766 920 : for (tree set = ctx; set && set != error_mark_node; set = TREE_CHAIN (set))
1767 : {
1768 512 : pp_string (pp, OMP_TSS_NAME (set));
1769 512 : pp_string (pp, " = {");
1770 512 : for (tree sel = OMP_TSS_TRAIT_SELECTORS (set);
1771 1106 : sel && sel != error_mark_node; sel = TREE_CHAIN (sel))
1772 : {
1773 594 : if (OMP_TS_CODE (sel) == OMP_TRAIT_INVALID)
1774 0 : pp_string (pp, "<unknown selector>");
1775 : else
1776 594 : pp_string (pp, OMP_TS_NAME (sel));
1777 594 : tree score = OMP_TS_SCORE (sel);
1778 594 : tree props = OMP_TS_PROPERTIES (sel);
1779 594 : if (props)
1780 : {
1781 288 : pp_string (pp, " (");
1782 288 : if (score)
1783 : {
1784 55 : pp_string (pp, "score(");
1785 55 : dump_generic_node (pp, score, spc + 4, flags, false);
1786 55 : pp_string (pp, "): ");
1787 : }
1788 592 : for (tree prop = props; prop; prop = TREE_CHAIN (prop))
1789 : {
1790 304 : if (OMP_TP_NAME (prop) == OMP_TP_NAMELIST_NODE)
1791 : {
1792 169 : const char *str = omp_context_name_list_prop (prop);
1793 169 : pp_string (pp, "\"");
1794 169 : pretty_print_string (pp, str, strlen (str) + 1);
1795 169 : pp_string (pp, "\"");
1796 : }
1797 135 : else if (OMP_TP_NAME (prop))
1798 6 : dump_generic_node (pp, OMP_TP_NAME (prop), spc + 4,
1799 : flags, false);
1800 129 : else if (OMP_TP_VALUE (prop))
1801 129 : dump_generic_node (pp, OMP_TP_VALUE (prop), spc + 4,
1802 : flags, false);
1803 304 : if (TREE_CHAIN (prop))
1804 : {
1805 16 : pp_comma (pp);
1806 16 : pp_space (pp);
1807 : }
1808 : }
1809 288 : pp_string (pp, ")");
1810 : }
1811 594 : if (TREE_CHAIN (sel))
1812 : {
1813 82 : pp_comma (pp);
1814 82 : pp_space (pp);
1815 : }
1816 : }
1817 512 : pp_string (pp, "}");
1818 512 : if (TREE_CHAIN (set))
1819 : {
1820 116 : pp_comma (pp);
1821 116 : newline_and_indent (pp, spc);
1822 : }
1823 : }
1824 408 : }
1825 :
1826 : /* Wrapper for above, used for "declare variant". Compare to
1827 : print_generic_expr. */
1828 : void
1829 308 : print_omp_context_selector (FILE *file, tree t, dump_flags_t flags)
1830 : {
1831 308 : maybe_init_pretty_print (file);
1832 308 : dump_omp_context_selector (tree_pp, t, 0, flags);
1833 308 : pp_flush (tree_pp);
1834 308 : }
1835 :
1836 : /* Dump location LOC to PP. */
1837 :
1838 : void
1839 2326 : dump_location (pretty_printer *pp, location_t loc, dump_flags_t flags)
1840 : {
1841 2326 : expanded_location xloc = expand_location (loc);
1842 2326 : int discriminator = get_discriminator_from_loc (loc);
1843 :
1844 2326 : pp_left_bracket (pp);
1845 2326 : if (xloc.file)
1846 : {
1847 2326 : pp_string (pp, xloc.file);
1848 2326 : pp_string (pp, ":");
1849 : }
1850 2326 : pp_decimal_int (pp, xloc.line);
1851 2326 : pp_colon (pp);
1852 2326 : pp_decimal_int (pp, xloc.column);
1853 2326 : if (discriminator && (flags & TDF_COMPARE_DEBUG) == 0)
1854 : {
1855 9 : pp_string (pp, " discrim ");
1856 9 : pp_decimal_int (pp, discriminator);
1857 : }
1858 2326 : pp_string (pp, "] ");
1859 2326 : }
1860 :
1861 :
1862 : /* Dump lexical block BLOCK. PP, SPC and FLAGS are as in
1863 : dump_generic_node. */
1864 :
1865 : static void
1866 6 : dump_block_node (pretty_printer *pp, tree block, int spc, dump_flags_t flags)
1867 : {
1868 6 : tree t;
1869 :
1870 6 : pp_string (pp, "BLOCK #");
1871 6 : pp_decimal_int (pp, BLOCK_NUMBER (block));
1872 6 : pp_character (pp, ' ');
1873 :
1874 6 : if (flags & TDF_ADDRESS)
1875 : {
1876 0 : pp_character (pp, '[');
1877 0 : pp_scalar (pp, "%p", (void *) block);
1878 0 : pp_string (pp, "] ");
1879 : }
1880 :
1881 6 : if (TREE_ASM_WRITTEN (block))
1882 0 : pp_string (pp, "[written] ");
1883 :
1884 6 : if (flags & TDF_SLIM)
1885 6 : return;
1886 :
1887 0 : if (BLOCK_SOURCE_LOCATION (block))
1888 0 : dump_location (pp, BLOCK_SOURCE_LOCATION (block), flags);
1889 :
1890 0 : newline_and_indent (pp, spc + 2);
1891 :
1892 0 : if (BLOCK_SUPERCONTEXT (block))
1893 : {
1894 0 : pp_string (pp, "SUPERCONTEXT: ");
1895 0 : dump_generic_node (pp, BLOCK_SUPERCONTEXT (block), 0,
1896 : flags | TDF_SLIM, false);
1897 0 : newline_and_indent (pp, spc + 2);
1898 : }
1899 :
1900 0 : if (BLOCK_SUBBLOCKS (block)
1901 0 : && (!lang_GNU_Fortran ()
1902 0 : || TREE_CODE (BLOCK_SUBBLOCKS (block)) != STATEMENT_LIST))
1903 : {
1904 0 : pp_string (pp, "SUBBLOCKS: ");
1905 0 : for (t = BLOCK_SUBBLOCKS (block); t; t = BLOCK_CHAIN (t))
1906 : {
1907 0 : dump_generic_node (pp, t, 0, flags | TDF_SLIM, false);
1908 0 : pp_space (pp);
1909 : }
1910 0 : newline_and_indent (pp, spc + 2);
1911 : }
1912 :
1913 0 : if (BLOCK_CHAIN (block))
1914 : {
1915 0 : pp_string (pp, "SIBLINGS: ");
1916 0 : for (t = BLOCK_CHAIN (block); t; t = BLOCK_CHAIN (t))
1917 : {
1918 0 : dump_generic_node (pp, t, 0, flags | TDF_SLIM, false);
1919 0 : pp_space (pp);
1920 : }
1921 0 : newline_and_indent (pp, spc + 2);
1922 : }
1923 :
1924 0 : if (BLOCK_VARS (block))
1925 : {
1926 0 : pp_string (pp, "VARS: ");
1927 0 : for (t = BLOCK_VARS (block); t; t = TREE_CHAIN (t))
1928 : {
1929 0 : dump_generic_node (pp, t, 0, flags, false);
1930 0 : pp_space (pp);
1931 : }
1932 0 : newline_and_indent (pp, spc + 2);
1933 : }
1934 :
1935 0 : if (vec_safe_length (BLOCK_NONLOCALIZED_VARS (block)) > 0)
1936 : {
1937 0 : unsigned i;
1938 0 : vec<tree, va_gc> *nlv = BLOCK_NONLOCALIZED_VARS (block);
1939 :
1940 0 : pp_string (pp, "NONLOCALIZED_VARS: ");
1941 0 : FOR_EACH_VEC_ELT (*nlv, i, t)
1942 : {
1943 0 : dump_generic_node (pp, t, 0, flags, false);
1944 0 : pp_space (pp);
1945 : }
1946 0 : newline_and_indent (pp, spc + 2);
1947 : }
1948 :
1949 0 : if (BLOCK_ABSTRACT_ORIGIN (block))
1950 : {
1951 0 : pp_string (pp, "ABSTRACT_ORIGIN: ");
1952 0 : dump_generic_node (pp, BLOCK_ABSTRACT_ORIGIN (block), 0,
1953 : flags | TDF_SLIM, false);
1954 0 : newline_and_indent (pp, spc + 2);
1955 : }
1956 :
1957 0 : if (BLOCK_FRAGMENT_ORIGIN (block))
1958 : {
1959 0 : pp_string (pp, "FRAGMENT_ORIGIN: ");
1960 0 : dump_generic_node (pp, BLOCK_FRAGMENT_ORIGIN (block), 0,
1961 : flags | TDF_SLIM, false);
1962 0 : newline_and_indent (pp, spc + 2);
1963 : }
1964 :
1965 0 : if (BLOCK_FRAGMENT_CHAIN (block))
1966 : {
1967 0 : pp_string (pp, "FRAGMENT_CHAIN: ");
1968 0 : for (t = BLOCK_FRAGMENT_CHAIN (block); t; t = BLOCK_FRAGMENT_CHAIN (t))
1969 : {
1970 0 : dump_generic_node (pp, t, 0, flags | TDF_SLIM, false);
1971 0 : pp_space (pp);
1972 : }
1973 0 : newline_and_indent (pp, spc + 2);
1974 : }
1975 : }
1976 :
1977 : /* Dump #pragma omp atomic memory order clause. */
1978 :
1979 : void
1980 1343 : dump_omp_atomic_memory_order (pretty_printer *pp, enum omp_memory_order mo)
1981 : {
1982 1343 : switch (mo & OMP_MEMORY_ORDER_MASK)
1983 : {
1984 1158 : case OMP_MEMORY_ORDER_RELAXED:
1985 1158 : pp_string (pp, " relaxed");
1986 1158 : break;
1987 52 : case OMP_MEMORY_ORDER_SEQ_CST:
1988 52 : pp_string (pp, " seq_cst");
1989 52 : break;
1990 37 : case OMP_MEMORY_ORDER_ACQ_REL:
1991 37 : pp_string (pp, " acq_rel");
1992 37 : break;
1993 32 : case OMP_MEMORY_ORDER_ACQUIRE:
1994 32 : pp_string (pp, " acquire");
1995 32 : break;
1996 64 : case OMP_MEMORY_ORDER_RELEASE:
1997 64 : pp_string (pp, " release");
1998 64 : break;
1999 : case OMP_MEMORY_ORDER_UNSPECIFIED:
2000 : break;
2001 0 : default:
2002 0 : gcc_unreachable ();
2003 : }
2004 1343 : switch (mo & OMP_FAIL_MEMORY_ORDER_MASK)
2005 : {
2006 0 : case OMP_FAIL_MEMORY_ORDER_RELAXED:
2007 0 : pp_string (pp, " fail(relaxed)");
2008 0 : break;
2009 0 : case OMP_FAIL_MEMORY_ORDER_SEQ_CST:
2010 0 : pp_string (pp, " fail(seq_cst)");
2011 0 : break;
2012 0 : case OMP_FAIL_MEMORY_ORDER_ACQUIRE:
2013 0 : pp_string (pp, " fail(acquire)");
2014 0 : break;
2015 : case OMP_FAIL_MEMORY_ORDER_UNSPECIFIED:
2016 : break;
2017 0 : default:
2018 0 : gcc_unreachable ();
2019 : }
2020 1343 : }
2021 :
2022 : /* Helper to dump a MEM_REF node. */
2023 :
2024 : static void
2025 1302009 : dump_mem_ref (pretty_printer *pp, tree node, int spc, dump_flags_t flags)
2026 : {
2027 1302009 : if ((TREE_CODE (node) == MEM_REF
2028 1302009 : || TREE_CODE (node) == TARGET_MEM_REF)
2029 1302009 : && (flags & TDF_GIMPLE))
2030 : {
2031 3 : pp_string (pp, "__MEM <");
2032 3 : dump_generic_node (pp, TREE_TYPE (node),
2033 : spc, flags | TDF_SLIM, false);
2034 6 : if (TYPE_ALIGN (TREE_TYPE (node))
2035 3 : != TYPE_ALIGN (TYPE_MAIN_VARIANT (TREE_TYPE (node))))
2036 : {
2037 3 : pp_string (pp, ", ");
2038 3 : pp_decimal_int (pp, TYPE_ALIGN (TREE_TYPE (node)));
2039 : }
2040 3 : pp_greater (pp);
2041 3 : pp_string (pp, " (");
2042 3 : if (TREE_TYPE (TREE_OPERAND (node, 0))
2043 3 : != TREE_TYPE (TREE_OPERAND (node, 1)))
2044 : {
2045 3 : pp_left_paren (pp);
2046 3 : dump_generic_node (pp, TREE_TYPE (TREE_OPERAND (node, 1)),
2047 : spc, flags | TDF_SLIM, false);
2048 3 : pp_right_paren (pp);
2049 : }
2050 3 : dump_generic_node (pp, TREE_OPERAND (node, 0),
2051 : spc, flags | TDF_SLIM, false);
2052 3 : if (! integer_zerop (TREE_OPERAND (node, 1)))
2053 : {
2054 0 : pp_string (pp, " + ");
2055 0 : dump_generic_node (pp, TREE_OPERAND (node, 1),
2056 : spc, flags | TDF_SLIM, false);
2057 : }
2058 3 : if (TREE_CODE (node) == TARGET_MEM_REF)
2059 : {
2060 0 : if (TREE_OPERAND (node, 2))
2061 : {
2062 : /* INDEX * STEP */
2063 0 : pp_string (pp, " + ");
2064 0 : dump_generic_node (pp, TREE_OPERAND (node, 2),
2065 : spc, flags | TDF_SLIM, false);
2066 0 : pp_string (pp, " * ");
2067 0 : dump_generic_node (pp, TREE_OPERAND (node, 3),
2068 : spc, flags | TDF_SLIM, false);
2069 : }
2070 0 : if (TREE_OPERAND (node, 4))
2071 : {
2072 : /* INDEX2 */
2073 0 : pp_string (pp, " + ");
2074 0 : dump_generic_node (pp, TREE_OPERAND (node, 4),
2075 : spc, flags | TDF_SLIM, false);
2076 : }
2077 : }
2078 3 : if (TREE_CODE (node) == MEM_REF
2079 3 : && REF_REVERSE_STORAGE_ORDER (node))
2080 : {
2081 0 : pp_string (pp, ", ");
2082 0 : pp_decimal_int (pp, REF_REVERSE_STORAGE_ORDER (node));
2083 : }
2084 3 : if (MR_DEPENDENCE_CLIQUE (node) != 0)
2085 : {
2086 0 : pp_string (pp, ", ");
2087 0 : pp_decimal_int (pp, MR_DEPENDENCE_CLIQUE (node));
2088 0 : pp_colon (pp);
2089 0 : pp_decimal_int (pp, MR_DEPENDENCE_BASE (node));
2090 : }
2091 3 : pp_right_paren (pp);
2092 : }
2093 1302006 : else if (TREE_CODE (node) == MEM_REF
2094 1275201 : && integer_zerop (TREE_OPERAND (node, 1))
2095 : /* Dump the types of INTEGER_CSTs explicitly, for we can't
2096 : infer them and MEM_ATTR caching will share MEM_REFs
2097 : with differently-typed op0s. */
2098 954895 : && TREE_CODE (TREE_OPERAND (node, 0)) != INTEGER_CST
2099 : /* Released SSA_NAMES have no TREE_TYPE. */
2100 954756 : && TREE_TYPE (TREE_OPERAND (node, 0)) != NULL_TREE
2101 : /* Same pointer types, but ignoring POINTER_TYPE vs.
2102 : REFERENCE_TYPE. */
2103 954756 : && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 0)))
2104 954756 : == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 1))))
2105 1519050 : && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 0)))
2106 759525 : == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 1))))
2107 759525 : && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 0)))
2108 759525 : == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 1))))
2109 : /* Same value types ignoring qualifiers. */
2110 759376 : && (TYPE_MAIN_VARIANT (TREE_TYPE (node))
2111 759376 : == TYPE_MAIN_VARIANT
2112 : (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 1)))))
2113 2045365 : && (!(flags & TDF_ALIAS)
2114 1480 : || MR_DEPENDENCE_CLIQUE (node) == 0))
2115 : {
2116 742045 : if (TREE_CODE (TREE_OPERAND (node, 0)) != ADDR_EXPR)
2117 : {
2118 : /* Enclose pointers to arrays in parentheses. */
2119 648982 : tree op0 = TREE_OPERAND (node, 0);
2120 648982 : tree op0type = TREE_TYPE (op0);
2121 648982 : if (POINTER_TYPE_P (op0type)
2122 648982 : && TREE_CODE (TREE_TYPE (op0type)) == ARRAY_TYPE)
2123 29404 : pp_left_paren (pp);
2124 648982 : pp_star (pp);
2125 648982 : dump_generic_node (pp, op0, spc, flags, false);
2126 648982 : if (POINTER_TYPE_P (op0type)
2127 648982 : && TREE_CODE (TREE_TYPE (op0type)) == ARRAY_TYPE)
2128 29404 : pp_right_paren (pp);
2129 : }
2130 : else
2131 93063 : dump_generic_node (pp,
2132 93063 : TREE_OPERAND (TREE_OPERAND (node, 0), 0),
2133 : spc, flags, false);
2134 : }
2135 : else
2136 : {
2137 559961 : pp_string (pp, "MEM");
2138 :
2139 559961 : tree nodetype = TREE_TYPE (node);
2140 559961 : tree op0 = TREE_OPERAND (node, 0);
2141 559961 : tree op1 = TREE_OPERAND (node, 1);
2142 559961 : tree op1type = TYPE_MAIN_VARIANT (TREE_TYPE (op1));
2143 :
2144 559961 : tree op0size = TYPE_SIZE (nodetype);
2145 559961 : tree op1size = TYPE_SIZE (TREE_TYPE (op1type));
2146 :
2147 559961 : if (!op0size || !op1size
2148 559961 : || !operand_equal_p (op0size, op1size, 0))
2149 : {
2150 222024 : pp_string (pp, " <");
2151 : /* If the size of the type of the operand is not the same
2152 : as the size of the MEM_REF expression include the type
2153 : of the latter similar to the TDF_GIMPLE output to make
2154 : it clear how many bytes of memory are being accessed. */
2155 222024 : dump_generic_node (pp, nodetype, spc, flags | TDF_SLIM, false);
2156 222024 : pp_string (pp, "> ");
2157 : }
2158 :
2159 559961 : pp_string (pp, "[(");
2160 559961 : dump_generic_node (pp, op1type, spc, flags | TDF_SLIM, false);
2161 559961 : pp_right_paren (pp);
2162 559961 : dump_generic_node (pp, op0, spc, flags, false);
2163 559961 : if (!integer_zerop (op1))
2164 : {
2165 323067 : pp_string (pp, " + ");
2166 323067 : dump_generic_node (pp, op1, spc, flags, false);
2167 : }
2168 559961 : if (TREE_CODE (node) == TARGET_MEM_REF)
2169 : {
2170 26805 : tree tmp = TMR_INDEX2 (node);
2171 26805 : if (tmp)
2172 : {
2173 291 : pp_string (pp, " + ");
2174 291 : dump_generic_node (pp, tmp, spc, flags, false);
2175 : }
2176 26805 : tmp = TMR_INDEX (node);
2177 26805 : if (tmp)
2178 : {
2179 22518 : pp_string (pp, " + ");
2180 22518 : dump_generic_node (pp, tmp, spc, flags, false);
2181 22518 : tmp = TMR_STEP (node);
2182 22518 : pp_string (pp, " * ");
2183 22518 : if (tmp)
2184 22500 : dump_generic_node (pp, tmp, spc, flags, false);
2185 : else
2186 18 : pp_string (pp, "1");
2187 : }
2188 : }
2189 559961 : if ((flags & TDF_ALIAS)
2190 559961 : && MR_DEPENDENCE_CLIQUE (node) != 0)
2191 : {
2192 1347 : pp_string (pp, " clique ");
2193 1347 : pp_unsigned_wide_integer (pp, MR_DEPENDENCE_CLIQUE (node));
2194 1347 : pp_string (pp, " base ");
2195 1347 : pp_unsigned_wide_integer (pp, MR_DEPENDENCE_BASE (node));
2196 : }
2197 559961 : pp_right_bracket (pp);
2198 : }
2199 1302009 : }
2200 :
2201 : /* Helper function for dump_generic_node. Dump INIT or COND expression for
2202 : OpenMP loop non-rectangular iterators. */
2203 :
2204 : void
2205 88 : dump_omp_loop_non_rect_expr (pretty_printer *pp, tree node, int spc,
2206 : dump_flags_t flags)
2207 : {
2208 88 : gcc_assert (TREE_CODE (node) == TREE_VEC);
2209 88 : dump_generic_node (pp, TREE_VEC_ELT (node, 0), spc, flags, false);
2210 88 : pp_string (pp, " * ");
2211 88 : if (op_prio (TREE_VEC_ELT (node, 1)) <= op_code_prio (MULT_EXPR))
2212 : {
2213 0 : pp_left_paren (pp);
2214 0 : dump_generic_node (pp, TREE_VEC_ELT (node, 1), spc, flags, false);
2215 0 : pp_right_paren (pp);
2216 : }
2217 : else
2218 88 : dump_generic_node (pp, TREE_VEC_ELT (node, 1), spc, flags, false);
2219 88 : pp_string (pp, " + ");
2220 88 : if (op_prio (TREE_VEC_ELT (node, 1)) <= op_code_prio (PLUS_EXPR))
2221 : {
2222 0 : pp_left_paren (pp);
2223 0 : dump_generic_node (pp, TREE_VEC_ELT (node, 2), spc, flags, false);
2224 0 : pp_right_paren (pp);
2225 : }
2226 : else
2227 88 : dump_generic_node (pp, TREE_VEC_ELT (node, 2), spc, flags, false);
2228 88 : }
2229 :
2230 : /* Dump the node NODE on the pretty_printer PP, SPC spaces of
2231 : indent. FLAGS specifies details to show in the dump (see TDF_* in
2232 : dumpfile.h). If IS_STMT is true, the object printed is considered
2233 : to be a statement and it is terminated by ';' if appropriate. */
2234 :
2235 : int
2236 46132471 : dump_generic_node (pretty_printer *pp, tree node, int spc, dump_flags_t flags,
2237 : bool is_stmt)
2238 : {
2239 46132471 : tree type;
2240 46132471 : tree op0, op1;
2241 46132471 : const char *str;
2242 46132471 : bool is_expr;
2243 46132471 : enum tree_code code;
2244 :
2245 46132471 : if (node == NULL_TREE)
2246 : return spc;
2247 :
2248 46111509 : is_expr = EXPR_P (node);
2249 :
2250 46111509 : if (is_stmt && (flags & TDF_STMTADDR))
2251 : {
2252 4 : pp_string (pp, "<&");
2253 4 : pp_scalar (pp, "%p", (void *)node);
2254 4 : pp_string (pp, "> ");
2255 : }
2256 :
2257 46111509 : if ((flags & TDF_LINENO) && EXPR_HAS_LOCATION (node))
2258 929 : dump_location (pp, EXPR_LOCATION (node), flags);
2259 :
2260 46111509 : code = TREE_CODE (node);
2261 46111509 : switch (code)
2262 : {
2263 14 : case ERROR_MARK:
2264 14 : pp_string (pp, "<<< error >>>");
2265 14 : break;
2266 :
2267 8952153 : case IDENTIFIER_NODE:
2268 8952153 : pp_tree_identifier (pp, node);
2269 8952153 : break;
2270 :
2271 : case TREE_LIST:
2272 58218 : while (node && node != error_mark_node)
2273 : {
2274 58218 : if (TREE_PURPOSE (node))
2275 : {
2276 21991 : dump_generic_node (pp, TREE_PURPOSE (node), spc, flags, false);
2277 21991 : pp_space (pp);
2278 : }
2279 58218 : dump_generic_node (pp, TREE_VALUE (node), spc, flags, false);
2280 58218 : node = TREE_CHAIN (node);
2281 58218 : if (node && TREE_CODE (node) == TREE_LIST)
2282 : {
2283 2450 : pp_comma (pp);
2284 2450 : pp_space (pp);
2285 : }
2286 : }
2287 : break;
2288 :
2289 0 : case TREE_BINFO:
2290 0 : dump_generic_node (pp, BINFO_TYPE (node), spc, flags, false);
2291 0 : break;
2292 :
2293 153 : case TREE_VEC:
2294 153 : {
2295 153 : size_t i;
2296 153 : pp_left_brace (pp);
2297 153 : if (TREE_VEC_LENGTH (node) > 0)
2298 : {
2299 153 : size_t len = TREE_VEC_LENGTH (node);
2300 459 : for (i = 0; i < len - 1; i++)
2301 : {
2302 306 : dump_generic_node (pp, TREE_VEC_ELT (node, i), spc, flags,
2303 : false);
2304 306 : pp_comma (pp);
2305 306 : pp_space (pp);
2306 : }
2307 153 : dump_generic_node (pp, TREE_VEC_ELT (node, len - 1), spc,
2308 : flags, false);
2309 : }
2310 153 : pp_right_brace (pp);
2311 : }
2312 153 : break;
2313 :
2314 4513337 : case VOID_TYPE:
2315 4513337 : case INTEGER_TYPE:
2316 4513337 : case REAL_TYPE:
2317 4513337 : case FIXED_POINT_TYPE:
2318 4513337 : case COMPLEX_TYPE:
2319 4513337 : case VECTOR_TYPE:
2320 4513337 : case ENUMERAL_TYPE:
2321 4513337 : case BOOLEAN_TYPE:
2322 4513337 : case BITINT_TYPE:
2323 4513337 : case OPAQUE_TYPE:
2324 4513337 : {
2325 4513337 : unsigned int quals = TYPE_QUALS (node);
2326 4513337 : enum tree_code_class tclass;
2327 :
2328 4513337 : if (quals & TYPE_QUAL_ATOMIC)
2329 534 : pp_string (pp, "atomic ");
2330 4513337 : if (quals & TYPE_QUAL_CONST)
2331 37754 : pp_string (pp, "const ");
2332 4513337 : if (quals & TYPE_QUAL_VOLATILE)
2333 3755 : pp_string (pp, "volatile ");
2334 4513337 : if (quals & TYPE_QUAL_RESTRICT)
2335 0 : pp_string (pp, "restrict ");
2336 :
2337 4513337 : if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))
2338 : {
2339 157 : pp_string (pp, "<address-space-");
2340 157 : pp_decimal_int (pp, TYPE_ADDR_SPACE (node));
2341 157 : pp_string (pp, "> ");
2342 : }
2343 :
2344 4513337 : tclass = TREE_CODE_CLASS (TREE_CODE (node));
2345 :
2346 4513337 : if (tclass == tcc_declaration)
2347 : {
2348 0 : if (DECL_NAME (node))
2349 0 : dump_decl_name (pp, node, flags);
2350 : else
2351 0 : pp_string (pp, "<unnamed type decl>");
2352 : }
2353 4513337 : else if (tclass == tcc_type)
2354 : {
2355 4513337 : if ((flags & TDF_GIMPLE) && node == sizetype)
2356 0 : pp_string (pp, "__SIZETYPE__");
2357 4513337 : else if (TYPE_NAME (node))
2358 : {
2359 2983338 : if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
2360 841931 : pp_tree_identifier (pp, TYPE_NAME (node));
2361 2141407 : else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
2362 2141407 : && DECL_NAME (TYPE_NAME (node)))
2363 2141407 : dump_decl_name (pp, TYPE_NAME (node), flags);
2364 : else
2365 0 : pp_string (pp, "<unnamed type>");
2366 : }
2367 1529999 : else if (TREE_CODE (node) == VECTOR_TYPE)
2368 : {
2369 1019687 : if (flags & TDF_GIMPLE)
2370 : {
2371 0 : dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2372 0 : pp_string (pp, " [[gnu::vector_size(");
2373 0 : pp_wide_integer
2374 0 : (pp, tree_to_poly_uint64 (TYPE_SIZE_UNIT (node)));
2375 0 : pp_string (pp, ")]]");
2376 : }
2377 : else
2378 : {
2379 1019687 : pp_string (pp, "vector");
2380 1019687 : pp_left_paren (pp);
2381 1019687 : pp_wide_integer (pp, TYPE_VECTOR_SUBPARTS (node));
2382 1019687 : pp_string (pp, ") ");
2383 1019687 : dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2384 : }
2385 : }
2386 : else if (TREE_CODE (node) == INTEGER_TYPE)
2387 : {
2388 441672 : if (TYPE_PRECISION (node) == CHAR_TYPE_SIZE)
2389 58023 : pp_string (pp, (TYPE_UNSIGNED (node)
2390 : ? "unsigned char"
2391 : : "signed char"));
2392 390040 : else if (TYPE_PRECISION (node) == SHORT_TYPE_SIZE)
2393 195689 : pp_string (pp, (TYPE_UNSIGNED (node)
2394 : ? "unsigned short"
2395 : : "signed short"));
2396 233634 : else if (TYPE_PRECISION (node) == INT_TYPE_SIZE)
2397 190456 : pp_string (pp, (TYPE_UNSIGNED (node)
2398 : ? "unsigned int"
2399 : : "signed int"));
2400 46889 : else if (TYPE_PRECISION (node) == LONG_TYPE_SIZE)
2401 44583 : pp_string (pp, (TYPE_UNSIGNED (node)
2402 : ? "unsigned long"
2403 : : "signed long"));
2404 4209 : else if (TYPE_PRECISION (node) == LONG_LONG_TYPE_SIZE)
2405 0 : pp_string (pp, (TYPE_UNSIGNED (node)
2406 : ? "unsigned long long"
2407 : : "signed long long"));
2408 4209 : else if (TYPE_PRECISION (node) >= CHAR_TYPE_SIZE
2409 4209 : && pow2p_hwi (TYPE_PRECISION (node)))
2410 : {
2411 6139 : pp_string (pp, (TYPE_UNSIGNED (node) ? "uint" : "int"));
2412 3676 : pp_decimal_int (pp, TYPE_PRECISION (node));
2413 3676 : pp_string (pp, "_t");
2414 : }
2415 : else
2416 : {
2417 702 : pp_string (pp, (TYPE_UNSIGNED (node)
2418 : ? "<unnamed-unsigned:"
2419 : : "<unnamed-signed:"));
2420 533 : pp_decimal_int (pp, TYPE_PRECISION (node));
2421 533 : pp_greater (pp);
2422 : }
2423 : }
2424 : else if (TREE_CODE (node) == COMPLEX_TYPE)
2425 : {
2426 6975 : pp_string (pp, "__complex__ ");
2427 6975 : dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2428 : }
2429 : else if (TREE_CODE (node) == REAL_TYPE)
2430 : {
2431 0 : pp_string (pp, "<float:");
2432 0 : pp_decimal_int (pp, TYPE_PRECISION (node));
2433 0 : pp_greater (pp);
2434 : }
2435 : else if (TREE_CODE (node) == FIXED_POINT_TYPE)
2436 : {
2437 0 : pp_string (pp, "<fixed-point-");
2438 0 : pp_string (pp, TYPE_SATURATING (node) ? "sat:" : "nonsat:");
2439 0 : pp_decimal_int (pp, TYPE_PRECISION (node));
2440 0 : pp_greater (pp);
2441 : }
2442 : else if (TREE_CODE (node) == BOOLEAN_TYPE)
2443 : {
2444 122920 : pp_string (pp, (TYPE_UNSIGNED (node)
2445 : ? "<unsigned-boolean:"
2446 : : "<signed-boolean:"));
2447 61460 : pp_decimal_int (pp, TYPE_PRECISION (node));
2448 61460 : pp_greater (pp);
2449 : }
2450 : else if (TREE_CODE (node) == BITINT_TYPE)
2451 : {
2452 134 : if (TYPE_UNSIGNED (node))
2453 34 : pp_string (pp, "unsigned ");
2454 134 : pp_string (pp, "_BitInt(");
2455 134 : pp_decimal_int (pp, TYPE_PRECISION (node));
2456 134 : pp_right_paren (pp);
2457 : }
2458 : else if (TREE_CODE (node) == VOID_TYPE)
2459 13 : pp_string (pp, "void");
2460 : else
2461 58 : pp_string (pp, "<unnamed type>");
2462 : }
2463 : break;
2464 : }
2465 :
2466 858141 : case POINTER_TYPE:
2467 858141 : case REFERENCE_TYPE:
2468 858141 : str = (TREE_CODE (node) == POINTER_TYPE ? "*" : "&");
2469 :
2470 858141 : if (TREE_TYPE (node) == NULL)
2471 : {
2472 0 : pp_string (pp, str);
2473 0 : pp_string (pp, "<null type>");
2474 : }
2475 858141 : else if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE)
2476 : {
2477 7426 : tree fnode = TREE_TYPE (node);
2478 :
2479 7426 : dump_generic_node (pp, TREE_TYPE (fnode), spc, flags, false);
2480 7426 : pp_space (pp);
2481 7426 : pp_left_paren (pp);
2482 7426 : pp_string (pp, str);
2483 7426 : if (TYPE_IDENTIFIER (node))
2484 2453 : dump_generic_node (pp, TYPE_NAME (node), spc, flags, false);
2485 4973 : else if (flags & TDF_NOUID)
2486 128 : pp_string (pp, "<Txxxx>");
2487 : else
2488 : {
2489 4845 : pp_string (pp, "<T");
2490 4845 : pp_scalar (pp, "%x", TYPE_UID (node));
2491 4845 : pp_character (pp, '>');
2492 : }
2493 :
2494 7426 : pp_right_paren (pp);
2495 7426 : dump_function_declaration (pp, fnode, spc, flags);
2496 : }
2497 : else
2498 : {
2499 850715 : unsigned int quals = TYPE_QUALS (node);
2500 :
2501 850715 : dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2502 850715 : pp_space (pp);
2503 850715 : pp_string (pp, str);
2504 :
2505 850715 : if (quals & TYPE_QUAL_CONST)
2506 3901 : pp_string (pp, " const");
2507 850715 : if (quals & TYPE_QUAL_VOLATILE)
2508 227 : pp_string (pp, " volatile");
2509 850715 : if (quals & TYPE_QUAL_RESTRICT)
2510 45840 : pp_string (pp, " restrict");
2511 :
2512 850715 : if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))
2513 : {
2514 0 : pp_string (pp, " <address-space-");
2515 0 : pp_decimal_int (pp, TYPE_ADDR_SPACE (node));
2516 0 : pp_greater (pp);
2517 : }
2518 :
2519 850715 : if (TYPE_REF_CAN_ALIAS_ALL (node))
2520 5026 : pp_string (pp, " {ref-all}");
2521 : }
2522 : break;
2523 :
2524 0 : case OFFSET_TYPE:
2525 0 : NIY;
2526 0 : break;
2527 :
2528 1302009 : case MEM_REF:
2529 1302009 : case TARGET_MEM_REF:
2530 1302009 : dump_mem_ref (pp, node, spc, flags);
2531 1302009 : break;
2532 :
2533 72695 : case ARRAY_TYPE:
2534 72695 : {
2535 72695 : unsigned int quals = TYPE_QUALS (node);
2536 72695 : tree tmp;
2537 :
2538 72695 : if (quals & TYPE_QUAL_ATOMIC)
2539 0 : pp_string (pp, "atomic ");
2540 72695 : if (quals & TYPE_QUAL_CONST)
2541 1 : pp_string (pp, "const ");
2542 72695 : if (quals & TYPE_QUAL_VOLATILE)
2543 0 : pp_string (pp, "volatile ");
2544 :
2545 : /* Print the innermost component type. */
2546 77685 : for (tmp = TREE_TYPE (node); TREE_CODE (tmp) == ARRAY_TYPE;
2547 4990 : tmp = TREE_TYPE (tmp))
2548 : ;
2549 :
2550 : /* Avoid to print recursively the array. */
2551 : /* FIXME : Not implemented correctly, see print_struct_decl. */
2552 72695 : if (TREE_CODE (tmp) != POINTER_TYPE || TREE_TYPE (tmp) != node)
2553 72695 : dump_generic_node (pp, tmp, spc, flags, false);
2554 :
2555 : /* Print the dimensions. */
2556 150380 : for (tmp = node; TREE_CODE (tmp) == ARRAY_TYPE; tmp = TREE_TYPE (tmp))
2557 77685 : dump_array_domain (pp, TYPE_DOMAIN (tmp), spc, flags);
2558 : break;
2559 : }
2560 :
2561 124851 : case RECORD_TYPE:
2562 124851 : case UNION_TYPE:
2563 124851 : case QUAL_UNION_TYPE:
2564 124851 : {
2565 124851 : unsigned int quals = TYPE_QUALS (node);
2566 :
2567 124851 : if (quals & TYPE_QUAL_ATOMIC)
2568 0 : pp_string (pp, "atomic ");
2569 124851 : if (quals & TYPE_QUAL_CONST)
2570 11657 : pp_string (pp, "const ");
2571 124851 : if (quals & TYPE_QUAL_VOLATILE)
2572 63 : pp_string (pp, "volatile ");
2573 :
2574 124851 : if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))
2575 : {
2576 1 : pp_string (pp, "<address-space-");
2577 1 : pp_decimal_int (pp, TYPE_ADDR_SPACE (node));
2578 1 : pp_string (pp, "> ");
2579 : }
2580 :
2581 : /* Print the name of the structure. */
2582 124851 : if (TREE_CODE (node) == RECORD_TYPE)
2583 123007 : pp_string (pp, "struct ");
2584 1844 : else if (TREE_CODE (node) == UNION_TYPE)
2585 1844 : pp_string (pp, "union ");
2586 :
2587 124851 : if (TYPE_NAME (node))
2588 121727 : dump_generic_node (pp, TYPE_NAME (node), spc, flags, false);
2589 3124 : else if (!(flags & TDF_SLIM))
2590 : /* FIXME: If we eliminate the 'else' above and attempt
2591 : to show the fields for named types, we may get stuck
2592 : following a cycle of pointers to structs. The alleged
2593 : self-reference check in print_struct_decl will not detect
2594 : cycles involving more than one pointer or struct type. */
2595 576 : print_struct_decl (pp, node, spc, flags);
2596 : break;
2597 : }
2598 :
2599 0 : case LANG_TYPE:
2600 0 : NIY;
2601 0 : break;
2602 :
2603 5564851 : case INTEGER_CST:
2604 5564851 : if (flags & TDF_GIMPLE
2605 5564851 : && (POINTER_TYPE_P (TREE_TYPE (node))
2606 47 : || (TYPE_PRECISION (TREE_TYPE (node))
2607 47 : < TYPE_PRECISION (integer_type_node))
2608 47 : || exact_log2 (TYPE_PRECISION (TREE_TYPE (node))) == -1
2609 47 : || tree_int_cst_sgn (node) < 0))
2610 : {
2611 0 : pp_string (pp, "_Literal (");
2612 0 : dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2613 0 : pp_string (pp, ") ");
2614 : }
2615 5564851 : if (TREE_CODE (TREE_TYPE (node)) == POINTER_TYPE
2616 5564851 : && ! (flags & TDF_GIMPLE))
2617 : {
2618 : /* In the case of a pointer, one may want to divide by the
2619 : size of the pointed-to type. Unfortunately, this not
2620 : straightforward. The C front-end maps expressions
2621 :
2622 : (int *) 5
2623 : int *p; (p + 5)
2624 :
2625 : in such a way that the two INTEGER_CST nodes for "5" have
2626 : different values but identical types. In the latter
2627 : case, the 5 is multiplied by sizeof (int) in c-common.cc
2628 : (pointer_int_sum) to convert it to a byte address, and
2629 : yet the type of the node is left unchanged. Argh. What
2630 : is consistent though is that the number value corresponds
2631 : to bytes (UNITS) offset.
2632 :
2633 : NB: Neither of the following divisors can be trivially
2634 : used to recover the original literal:
2635 :
2636 : TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
2637 : TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
2638 444973 : pp_wide_integer (pp, TREE_INT_CST_LOW (node));
2639 444973 : pp_string (pp, "B"); /* pseudo-unit */
2640 : }
2641 5119878 : else if (tree_fits_shwi_p (node))
2642 5102389 : pp_wide_integer (pp, tree_to_shwi (node));
2643 17489 : else if (tree_fits_uhwi_p (node))
2644 16934 : pp_unsigned_wide_integer (pp, tree_to_uhwi (node));
2645 : else
2646 : {
2647 555 : wide_int val = wi::to_wide (node);
2648 :
2649 555 : if (wi::neg_p (val, TYPE_SIGN (TREE_TYPE (node))))
2650 : {
2651 11 : pp_minus (pp);
2652 11 : val = -val;
2653 : }
2654 555 : unsigned int len;
2655 555 : print_hex_buf_size (val, &len);
2656 555 : if (UNLIKELY (len > sizeof (pp_buffer (pp)->m_digit_buffer)))
2657 : {
2658 0 : char *buf = XALLOCAVEC (char, len);
2659 0 : print_hex (val, buf);
2660 0 : pp_string (pp, buf);
2661 : }
2662 : else
2663 : {
2664 555 : print_hex (val, pp_buffer (pp)->m_digit_buffer);
2665 555 : pp_string (pp, pp_buffer (pp)->m_digit_buffer);
2666 : }
2667 555 : }
2668 5564851 : if ((flags & TDF_GIMPLE)
2669 5564851 : && ! (POINTER_TYPE_P (TREE_TYPE (node))
2670 47 : || (TYPE_PRECISION (TREE_TYPE (node))
2671 47 : < TYPE_PRECISION (integer_type_node))
2672 47 : || exact_log2 (TYPE_PRECISION (TREE_TYPE (node))) == -1))
2673 : {
2674 47 : if (TYPE_UNSIGNED (TREE_TYPE (node)))
2675 0 : pp_character (pp, 'u');
2676 47 : if (TYPE_PRECISION (TREE_TYPE (node))
2677 47 : == TYPE_PRECISION (unsigned_type_node))
2678 : ;
2679 0 : else if (TYPE_PRECISION (TREE_TYPE (node))
2680 0 : == TYPE_PRECISION (long_unsigned_type_node))
2681 0 : pp_character (pp, 'l');
2682 0 : else if (TYPE_PRECISION (TREE_TYPE (node))
2683 0 : == TYPE_PRECISION (long_long_unsigned_type_node))
2684 0 : pp_string (pp, "ll");
2685 : }
2686 5564851 : if (TREE_OVERFLOW (node))
2687 77 : pp_string (pp, "(OVF)");
2688 : break;
2689 :
2690 0 : case POLY_INT_CST:
2691 0 : pp_string (pp, "POLY_INT_CST [");
2692 0 : dump_generic_node (pp, POLY_INT_CST_COEFF (node, 0), spc, flags, false);
2693 0 : for (unsigned int i = 1; i < NUM_POLY_INT_COEFFS; ++i)
2694 : {
2695 : pp_string (pp, ", ");
2696 : dump_generic_node (pp, POLY_INT_CST_COEFF (node, i),
2697 : spc, flags, false);
2698 : }
2699 0 : pp_string (pp, "]");
2700 0 : break;
2701 :
2702 146228 : case REAL_CST:
2703 : /* Code copied from print_node. */
2704 146228 : {
2705 146228 : REAL_VALUE_TYPE d;
2706 146228 : if (TREE_OVERFLOW (node))
2707 0 : pp_string (pp, " overflow");
2708 :
2709 146228 : d = TREE_REAL_CST (node);
2710 146228 : if (REAL_VALUE_ISINF (d))
2711 6505 : pp_string (pp, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf");
2712 140197 : else if (REAL_VALUE_ISNAN (d))
2713 2180 : pp_string (pp, " Nan");
2714 : else
2715 : {
2716 138017 : char string[100];
2717 138017 : real_to_decimal (string, &d, sizeof (string), 0, 1);
2718 138017 : pp_string (pp, string);
2719 : }
2720 146228 : break;
2721 : }
2722 :
2723 0 : case FIXED_CST:
2724 0 : {
2725 0 : char string[100];
2726 0 : fixed_to_decimal (string, TREE_FIXED_CST_PTR (node), sizeof (string));
2727 0 : pp_string (pp, string);
2728 0 : break;
2729 : }
2730 :
2731 1576 : case COMPLEX_CST:
2732 1576 : pp_string (pp, "__complex__ (");
2733 1576 : dump_generic_node (pp, TREE_REALPART (node), spc, flags, false);
2734 1576 : pp_string (pp, ", ");
2735 1576 : dump_generic_node (pp, TREE_IMAGPART (node), spc, flags, false);
2736 1576 : pp_right_paren (pp);
2737 1576 : break;
2738 :
2739 61449 : case STRING_CST:
2740 61449 : {
2741 61449 : pp_string (pp, "\"");
2742 61449 : if (unsigned nbytes = TREE_STRING_LENGTH (node))
2743 61210 : pretty_print_string (pp, TREE_STRING_POINTER (node), nbytes);
2744 61449 : pp_string (pp, "\"");
2745 61449 : break;
2746 : }
2747 :
2748 144433 : case VECTOR_CST:
2749 144433 : {
2750 144433 : unsigned i;
2751 144433 : if (flags & TDF_GIMPLE)
2752 : {
2753 0 : pp_string (pp, "_Literal (");
2754 0 : dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2755 0 : pp_string (pp, ") ");
2756 : }
2757 144433 : pp_string (pp, "{ ");
2758 144433 : unsigned HOST_WIDE_INT nunits;
2759 144433 : if (!VECTOR_CST_NELTS (node).is_constant (&nunits))
2760 : nunits = vector_cst_encoded_nelts (node);
2761 1053204 : for (i = 0; i < nunits; ++i)
2762 : {
2763 908771 : if (i != 0)
2764 764338 : pp_string (pp, ", ");
2765 908771 : dump_generic_node (pp, VECTOR_CST_ELT (node, i),
2766 : spc, flags, false);
2767 : }
2768 144433 : if (!VECTOR_CST_NELTS (node).is_constant ())
2769 : pp_string (pp, ", ...");
2770 144433 : pp_string (pp, " }");
2771 : }
2772 144433 : break;
2773 :
2774 : case RAW_DATA_CST:
2775 0 : for (unsigned i = 0; i < (unsigned) RAW_DATA_LENGTH (node); ++i)
2776 : {
2777 0 : if (TYPE_UNSIGNED (TREE_TYPE (node))
2778 0 : || TYPE_PRECISION (TREE_TYPE (node)) > CHAR_BIT)
2779 0 : pp_decimal_int (pp, RAW_DATA_UCHAR_ELT (node, i));
2780 : else
2781 0 : pp_decimal_int (pp, RAW_DATA_SCHAR_ELT (node, i));
2782 0 : if (i == RAW_DATA_LENGTH (node) - 1U)
2783 : break;
2784 0 : else if (i == 9 && RAW_DATA_LENGTH (node) > 20)
2785 : {
2786 0 : pp_string (pp, ", ..., ");
2787 0 : i = RAW_DATA_LENGTH (node) - 11;
2788 : }
2789 : else
2790 0 : pp_string (pp, ", ");
2791 : }
2792 : break;
2793 :
2794 70 : case FUNCTION_TYPE:
2795 70 : case METHOD_TYPE:
2796 70 : dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2797 70 : pp_space (pp);
2798 70 : if (TREE_CODE (node) == METHOD_TYPE)
2799 : {
2800 70 : if (TYPE_METHOD_BASETYPE (node))
2801 70 : dump_generic_node (pp, TYPE_NAME (TYPE_METHOD_BASETYPE (node)),
2802 : spc, flags, false);
2803 : else
2804 0 : pp_string (pp, "<null method basetype>");
2805 70 : pp_colon_colon (pp);
2806 : }
2807 70 : if (TYPE_IDENTIFIER (node))
2808 0 : dump_generic_node (pp, TYPE_NAME (node), spc, flags, false);
2809 70 : else if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))
2810 0 : dump_decl_name (pp, TYPE_NAME (node), flags);
2811 70 : else if (flags & TDF_NOUID)
2812 0 : pp_string (pp, "<Txxxx>");
2813 : else
2814 : {
2815 70 : pp_string (pp, "<T");
2816 70 : pp_scalar (pp, "%x", TYPE_UID (node));
2817 70 : pp_character (pp, '>');
2818 : }
2819 70 : dump_function_declaration (pp, node, spc, flags);
2820 70 : break;
2821 :
2822 23273 : case FUNCTION_DECL:
2823 23273 : case CONST_DECL:
2824 23273 : dump_decl_name (pp, node, flags);
2825 23273 : break;
2826 :
2827 122747 : case LABEL_DECL:
2828 122747 : if (DECL_NAME (node))
2829 53505 : dump_decl_name (pp, node, flags);
2830 69242 : else if (LABEL_DECL_UID (node) != -1)
2831 : {
2832 24466 : if (flags & TDF_GIMPLE)
2833 : {
2834 35 : pp_character (pp, 'L');
2835 35 : pp_decimal_int (pp, (int) LABEL_DECL_UID (node));
2836 : }
2837 : else
2838 : {
2839 24431 : pp_string (pp, "<L");
2840 24431 : pp_decimal_int (pp, (int) LABEL_DECL_UID (node));
2841 24431 : pp_character (pp, '>');
2842 : }
2843 : }
2844 : else
2845 : {
2846 44776 : if (flags & TDF_NOUID)
2847 6 : pp_string (pp, "<D.xxxx>");
2848 : else
2849 : {
2850 44770 : if (flags & TDF_GIMPLE)
2851 : {
2852 6 : pp_character (pp, 'D');
2853 6 : pp_scalar (pp, "%u", DECL_UID (node));
2854 : }
2855 : else
2856 : {
2857 44764 : pp_string (pp, "<D.");
2858 44764 : pp_scalar (pp, "%u", DECL_UID (node));
2859 44764 : pp_character (pp, '>');
2860 : }
2861 : }
2862 : }
2863 : break;
2864 :
2865 72109 : case TYPE_DECL:
2866 72109 : if (DECL_IS_UNDECLARED_BUILTIN (node))
2867 : {
2868 : /* Don't print the declaration of built-in types. */
2869 : break;
2870 : }
2871 66935 : if (DECL_NAME (node))
2872 66880 : dump_decl_name (pp, node, flags);
2873 55 : else if (TYPE_NAME (TREE_TYPE (node)) != node)
2874 : {
2875 95 : pp_string (pp, (TREE_CODE (TREE_TYPE (node)) == UNION_TYPE
2876 : ? "union" : "struct "));
2877 49 : dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2878 : }
2879 : else
2880 6 : pp_string (pp, "<anon>");
2881 : break;
2882 :
2883 3633793 : case VAR_DECL:
2884 3633793 : case PARM_DECL:
2885 3633793 : case FIELD_DECL:
2886 3633793 : case DEBUG_EXPR_DECL:
2887 3633793 : case NAMESPACE_DECL:
2888 3633793 : case NAMELIST_DECL:
2889 3633793 : dump_decl_name (pp, node, flags);
2890 3633793 : break;
2891 :
2892 22935 : case RESULT_DECL:
2893 22935 : pp_string (pp, "<retval>");
2894 22935 : break;
2895 :
2896 624704 : case COMPONENT_REF:
2897 624704 : op0 = TREE_OPERAND (node, 0);
2898 624704 : str = ".";
2899 624704 : if (op0
2900 624704 : && (TREE_CODE (op0) == INDIRECT_REF
2901 584273 : || (TREE_CODE (op0) == MEM_REF
2902 193735 : && TREE_CODE (TREE_OPERAND (op0, 0)) != ADDR_EXPR
2903 161714 : && integer_zerop (TREE_OPERAND (op0, 1))
2904 : /* Dump the types of INTEGER_CSTs explicitly, for we
2905 : can't infer them and MEM_ATTR caching will share
2906 : MEM_REFs with differently-typed op0s. */
2907 156938 : && TREE_CODE (TREE_OPERAND (op0, 0)) != INTEGER_CST
2908 : /* Released SSA_NAMES have no TREE_TYPE. */
2909 156902 : && TREE_TYPE (TREE_OPERAND (op0, 0)) != NULL_TREE
2910 : /* Same pointer types, but ignoring POINTER_TYPE vs.
2911 : REFERENCE_TYPE. */
2912 156902 : && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 0)))
2913 156902 : == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 1))))
2914 302618 : && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0, 0)))
2915 151309 : == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0, 1))))
2916 151309 : && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0, 0)))
2917 151309 : == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0, 1))))
2918 : /* Same value types ignoring qualifiers. */
2919 151309 : && (TYPE_MAIN_VARIANT (TREE_TYPE (op0))
2920 151309 : == TYPE_MAIN_VARIANT
2921 : (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 1)))))
2922 151309 : && MR_DEPENDENCE_CLIQUE (op0) == 0)))
2923 : {
2924 178639 : op0 = TREE_OPERAND (op0, 0);
2925 178639 : str = "->";
2926 : }
2927 624704 : if (op_prio (op0) < op_prio (node))
2928 7111 : pp_left_paren (pp);
2929 624704 : dump_generic_node (pp, op0, spc, flags, false);
2930 624704 : if (op_prio (op0) < op_prio (node))
2931 7111 : pp_right_paren (pp);
2932 624704 : pp_string (pp, str);
2933 624704 : op1 = TREE_OPERAND (node, 1);
2934 624704 : dump_generic_node (pp, op1, spc, flags, false);
2935 624704 : if (DECL_P (op1)) /* Not always a decl in the C++ FE. */
2936 624704 : if (tree off = component_ref_field_offset (node))
2937 624630 : if (TREE_CODE (off) != INTEGER_CST)
2938 : {
2939 20 : pp_string (pp, "{off: ");
2940 20 : dump_generic_node (pp, off, spc, flags, false);
2941 20 : pp_right_brace (pp);
2942 : }
2943 : break;
2944 :
2945 23204 : case BIT_FIELD_REF:
2946 23204 : if (flags & TDF_GIMPLE)
2947 : {
2948 0 : pp_string (pp, "__BIT_FIELD_REF <");
2949 0 : dump_generic_node (pp, TREE_TYPE (node),
2950 : spc, flags | TDF_SLIM, false);
2951 0 : if (TYPE_ALIGN (TREE_TYPE (node))
2952 0 : != TYPE_ALIGN (TYPE_MAIN_VARIANT (TREE_TYPE (node))))
2953 : {
2954 0 : pp_string (pp, ", ");
2955 0 : pp_decimal_int (pp, TYPE_ALIGN (TREE_TYPE (node)));
2956 : }
2957 0 : pp_greater (pp);
2958 0 : pp_string (pp, " (");
2959 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc,
2960 : flags | TDF_SLIM, false);
2961 0 : pp_string (pp, ", ");
2962 0 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc,
2963 : flags | TDF_SLIM, false);
2964 0 : pp_string (pp, ", ");
2965 0 : dump_generic_node (pp, TREE_OPERAND (node, 2), spc,
2966 : flags | TDF_SLIM, false);
2967 0 : pp_right_paren (pp);
2968 : }
2969 : else
2970 : {
2971 23204 : pp_string (pp, "BIT_FIELD_REF <");
2972 23204 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2973 23204 : pp_string (pp, ", ");
2974 23204 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2975 23204 : pp_string (pp, ", ");
2976 23204 : dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2977 23204 : pp_greater (pp);
2978 : }
2979 : break;
2980 :
2981 0 : case BIT_INSERT_EXPR:
2982 0 : pp_string (pp, "BIT_INSERT_EXPR <");
2983 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2984 0 : pp_string (pp, ", ");
2985 0 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2986 0 : pp_string (pp, ", ");
2987 0 : dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2988 0 : pp_string (pp, " (");
2989 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (node, 1))))
2990 0 : pp_decimal_int (pp,
2991 : TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (node, 1))));
2992 : else
2993 0 : dump_generic_node (pp, TYPE_SIZE (TREE_TYPE (TREE_OPERAND (node, 1))),
2994 : spc, flags, false);
2995 0 : pp_string (pp, " bits)>");
2996 0 : break;
2997 :
2998 2008651 : case ARRAY_REF:
2999 2008651 : case ARRAY_RANGE_REF:
3000 2008651 : op0 = TREE_OPERAND (node, 0);
3001 2008651 : if (op_prio (op0) < op_prio (node))
3002 9530 : pp_left_paren (pp);
3003 2008651 : dump_generic_node (pp, op0, spc, flags, false);
3004 2008651 : if (op_prio (op0) < op_prio (node))
3005 9530 : pp_right_paren (pp);
3006 2008651 : pp_left_bracket (pp);
3007 2008651 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3008 2008651 : if (TREE_CODE (node) == ARRAY_RANGE_REF)
3009 122 : pp_string (pp, " ...");
3010 2008651 : pp_right_bracket (pp);
3011 :
3012 2008651 : op0 = array_ref_low_bound (node);
3013 2008651 : op1 = array_ref_element_size (node);
3014 :
3015 2008651 : if (!integer_zerop (op0)
3016 1987732 : || TREE_OPERAND (node, 2)
3017 3996383 : || TREE_OPERAND (node, 3))
3018 : {
3019 20967 : pp_string (pp, "{lb: ");
3020 20967 : dump_generic_node (pp, op0, spc, flags, false);
3021 20967 : pp_string (pp, " sz: ");
3022 20967 : dump_generic_node (pp, op1, spc, flags, false);
3023 20967 : pp_right_brace (pp);
3024 : }
3025 : break;
3026 :
3027 13 : case OMP_ARRAY_SECTION:
3028 13 : op0 = TREE_OPERAND (node, 0);
3029 13 : if (op_prio (op0) < op_prio (node))
3030 13 : pp_left_paren (pp);
3031 13 : dump_generic_node (pp, op0, spc, flags, false);
3032 13 : if (op_prio (op0) < op_prio (node))
3033 13 : pp_right_paren (pp);
3034 13 : pp_left_bracket (pp);
3035 13 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3036 13 : pp_colon (pp);
3037 13 : dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
3038 13 : pp_right_bracket (pp);
3039 13 : break;
3040 :
3041 55636 : case CONSTRUCTOR:
3042 55636 : {
3043 55636 : unsigned HOST_WIDE_INT ix;
3044 55636 : tree field, val;
3045 55636 : bool is_struct_init = false;
3046 55636 : bool is_array_init = false;
3047 55636 : widest_int curidx;
3048 55636 : if (flags & TDF_GIMPLE)
3049 : {
3050 0 : pp_string (pp, "_Literal (");
3051 0 : dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
3052 0 : pp_string (pp, ") ");
3053 : }
3054 55636 : pp_left_brace (pp);
3055 55636 : if (TREE_CLOBBER_P (node))
3056 : {
3057 20336 : pp_string (pp, "CLOBBER");
3058 20336 : switch (CLOBBER_KIND (node))
3059 : {
3060 0 : case CLOBBER_STORAGE_BEGIN:
3061 0 : pp_string (pp, "(bos)");
3062 0 : break;
3063 13369 : case CLOBBER_STORAGE_END:
3064 13369 : pp_string (pp, "(eos)");
3065 13369 : break;
3066 652 : case CLOBBER_OBJECT_BEGIN:
3067 652 : pp_string (pp, "(bob)");
3068 652 : break;
3069 763 : case CLOBBER_OBJECT_END:
3070 763 : pp_string (pp, "(eob)");
3071 763 : break;
3072 : default:
3073 : break;
3074 : }
3075 : }
3076 35300 : else if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
3077 35300 : || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
3078 : is_struct_init = true;
3079 25094 : else if (TREE_CODE (TREE_TYPE (node)) == ARRAY_TYPE
3080 6647 : && TYPE_DOMAIN (TREE_TYPE (node))
3081 6647 : && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node)))
3082 31741 : && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node))))
3083 : == INTEGER_CST)
3084 : {
3085 6647 : tree minv = TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node)));
3086 6647 : is_array_init = true;
3087 6647 : curidx = wi::to_widest (minv);
3088 : }
3089 223549 : FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), ix, field, val)
3090 : {
3091 167913 : if (field)
3092 : {
3093 78576 : if (is_struct_init)
3094 : {
3095 35212 : pp_dot (pp);
3096 35212 : dump_generic_node (pp, field, spc, flags, false);
3097 35212 : pp_equal (pp);
3098 : }
3099 43364 : else if (is_array_init
3100 43364 : && (TREE_CODE (field) != INTEGER_CST
3101 43364 : || curidx != wi::to_widest (field)))
3102 : {
3103 94 : pp_left_bracket (pp);
3104 94 : if (TREE_CODE (field) == RANGE_EXPR)
3105 : {
3106 94 : dump_generic_node (pp, TREE_OPERAND (field, 0), spc,
3107 : flags, false);
3108 94 : pp_string (pp, " ... ");
3109 94 : dump_generic_node (pp, TREE_OPERAND (field, 1), spc,
3110 : flags, false);
3111 94 : if (TREE_CODE (TREE_OPERAND (field, 1)) == INTEGER_CST)
3112 94 : curidx = wi::to_widest (TREE_OPERAND (field, 1));
3113 : }
3114 : else
3115 0 : dump_generic_node (pp, field, spc, flags, false);
3116 94 : if (TREE_CODE (field) == INTEGER_CST)
3117 0 : curidx = wi::to_widest (field);
3118 94 : pp_string (pp, "]=");
3119 : }
3120 : }
3121 167913 : if (is_array_init)
3122 52904 : curidx += 1;
3123 167913 : if (val && TREE_CODE (val) == ADDR_EXPR)
3124 2610 : if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL)
3125 140 : val = TREE_OPERAND (val, 0);
3126 167913 : if (val && TREE_CODE (val) == FUNCTION_DECL)
3127 140 : dump_decl_name (pp, val, flags);
3128 : else
3129 167773 : dump_generic_node (pp, val, spc, flags, false);
3130 335826 : if (ix != CONSTRUCTOR_NELTS (node) - 1)
3131 : {
3132 134575 : pp_comma (pp);
3133 134575 : pp_space (pp);
3134 : }
3135 : }
3136 55636 : pp_right_brace (pp);
3137 55636 : }
3138 55636 : break;
3139 :
3140 604 : case COMPOUND_EXPR:
3141 604 : {
3142 604 : tree *tp;
3143 604 : if (flags & TDF_SLIM)
3144 : {
3145 0 : pp_string (pp, "<COMPOUND_EXPR>");
3146 0 : break;
3147 : }
3148 :
3149 604 : dump_generic_node (pp, TREE_OPERAND (node, 0),
3150 : spc, flags, false);
3151 604 : pp_comma (pp);
3152 604 : pp_space (pp);
3153 :
3154 604 : for (tp = &TREE_OPERAND (node, 1);
3155 627 : TREE_CODE (*tp) == COMPOUND_EXPR;
3156 23 : tp = &TREE_OPERAND (*tp, 1))
3157 : {
3158 23 : dump_generic_node (pp, TREE_OPERAND (*tp, 0),
3159 : spc, flags, false);
3160 23 : pp_comma (pp);
3161 23 : pp_space (pp);
3162 : }
3163 :
3164 604 : dump_generic_node (pp, *tp, spc, flags, false);
3165 : }
3166 604 : break;
3167 :
3168 65090 : case STATEMENT_LIST:
3169 65090 : {
3170 65090 : tree_stmt_iterator si;
3171 65090 : bool first = true;
3172 :
3173 65090 : if (flags & TDF_SLIM)
3174 : {
3175 1 : pp_string (pp, "<STATEMENT_LIST>");
3176 1 : break;
3177 : }
3178 :
3179 426746 : for (si = tsi_start (node); !tsi_end_p (si); tsi_next (&si))
3180 : {
3181 361657 : if (!first)
3182 297302 : newline_and_indent (pp, spc);
3183 : else
3184 : first = false;
3185 361657 : dump_generic_node (pp, tsi_stmt (si), spc, flags, true);
3186 : }
3187 : }
3188 65089 : break;
3189 :
3190 206782 : case MODIFY_EXPR:
3191 206782 : case INIT_EXPR:
3192 206782 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags,
3193 : false);
3194 206782 : pp_space (pp);
3195 206782 : pp_equal (pp);
3196 206782 : pp_space (pp);
3197 206782 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags,
3198 : false);
3199 206782 : break;
3200 :
3201 2156 : case TARGET_EXPR:
3202 2156 : pp_string (pp, "TARGET_EXPR <");
3203 2156 : dump_generic_node (pp, TARGET_EXPR_SLOT (node), spc, flags, false);
3204 2156 : pp_comma (pp);
3205 2156 : pp_space (pp);
3206 2156 : dump_generic_node (pp, TARGET_EXPR_INITIAL (node), spc, flags, false);
3207 2156 : pp_greater (pp);
3208 2156 : break;
3209 :
3210 12225 : case DECL_EXPR:
3211 12225 : print_declaration (pp, DECL_EXPR_DECL (node), spc, flags);
3212 12225 : is_stmt = false;
3213 12225 : break;
3214 :
3215 48093 : case COND_EXPR:
3216 48093 : if (TREE_TYPE (node) == NULL || TREE_TYPE (node) == void_type_node)
3217 : {
3218 43432 : pp_string (pp, "if (");
3219 43432 : dump_generic_node (pp, COND_EXPR_COND (node), spc, flags, false);
3220 43432 : pp_right_paren (pp);
3221 : /* The lowered cond_exprs should always be printed in full. */
3222 43432 : if (COND_EXPR_THEN (node)
3223 43432 : && (IS_EMPTY_STMT (COND_EXPR_THEN (node))
3224 42558 : || TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR)
3225 15702 : && COND_EXPR_ELSE (node)
3226 59133 : && (IS_EMPTY_STMT (COND_EXPR_ELSE (node))
3227 2382 : || TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR))
3228 : {
3229 14813 : pp_space (pp);
3230 14813 : dump_generic_node (pp, COND_EXPR_THEN (node),
3231 : 0, flags, true);
3232 14813 : if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
3233 : {
3234 1494 : pp_string (pp, " else ");
3235 1494 : dump_generic_node (pp, COND_EXPR_ELSE (node),
3236 : 0, flags, true);
3237 : }
3238 : }
3239 28619 : else if (!(flags & TDF_SLIM))
3240 : {
3241 : /* Output COND_EXPR_THEN. */
3242 28619 : if (COND_EXPR_THEN (node))
3243 : {
3244 28619 : newline_and_indent (pp, spc+2);
3245 28619 : pp_left_brace (pp);
3246 28619 : newline_and_indent (pp, spc+4);
3247 28619 : dump_generic_node (pp, COND_EXPR_THEN (node), spc+4,
3248 : flags, true);
3249 28619 : newline_and_indent (pp, spc+2);
3250 28619 : pp_right_brace (pp);
3251 : }
3252 :
3253 : /* Output COND_EXPR_ELSE. */
3254 28619 : if (COND_EXPR_ELSE (node)
3255 28619 : && !IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
3256 : {
3257 7986 : newline_and_indent (pp, spc);
3258 7986 : pp_string (pp, "else");
3259 7986 : newline_and_indent (pp, spc+2);
3260 7986 : pp_left_brace (pp);
3261 7986 : newline_and_indent (pp, spc+4);
3262 7986 : dump_generic_node (pp, COND_EXPR_ELSE (node), spc+4,
3263 : flags, true);
3264 7986 : newline_and_indent (pp, spc+2);
3265 7986 : pp_right_brace (pp);
3266 : }
3267 : }
3268 : is_expr = false;
3269 : }
3270 : else
3271 : {
3272 4661 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3273 4661 : pp_space (pp);
3274 4661 : pp_question (pp);
3275 4661 : pp_space (pp);
3276 4661 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3277 4661 : pp_space (pp);
3278 4661 : pp_colon (pp);
3279 4661 : pp_space (pp);
3280 4661 : dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
3281 : }
3282 : break;
3283 :
3284 42491 : case BIND_EXPR:
3285 42491 : pp_left_brace (pp);
3286 42491 : if (!(flags & TDF_SLIM))
3287 : {
3288 42491 : if (BIND_EXPR_VARS (node))
3289 : {
3290 34794 : pp_newline (pp);
3291 :
3292 148148 : for (op0 = BIND_EXPR_VARS (node); op0; op0 = DECL_CHAIN (op0))
3293 : {
3294 113354 : print_declaration (pp, op0, spc+2, flags);
3295 113354 : pp_newline (pp);
3296 : }
3297 : }
3298 :
3299 42491 : newline_and_indent (pp, spc+2);
3300 42491 : dump_generic_node (pp, BIND_EXPR_BODY (node), spc+2, flags, true);
3301 42491 : newline_and_indent (pp, spc);
3302 42491 : pp_right_brace (pp);
3303 : }
3304 : is_expr = false;
3305 : break;
3306 :
3307 65843 : case CALL_EXPR:
3308 65843 : if (CALL_EXPR_FN (node) != NULL_TREE)
3309 65696 : print_call_name (pp, CALL_EXPR_FN (node), flags);
3310 : else
3311 : {
3312 147 : pp_dot (pp);
3313 147 : pp_string (pp, internal_fn_name (CALL_EXPR_IFN (node)));
3314 : }
3315 :
3316 : /* Print parameters. */
3317 65843 : pp_space (pp);
3318 65843 : pp_left_paren (pp);
3319 65843 : {
3320 65843 : tree arg;
3321 65843 : call_expr_arg_iterator iter;
3322 252929 : FOR_EACH_CALL_EXPR_ARG (arg, iter, node)
3323 : {
3324 121243 : dump_generic_node (pp, arg, spc, flags, false);
3325 121243 : if (more_call_expr_args_p (&iter))
3326 : {
3327 62664 : pp_comma (pp);
3328 62664 : pp_space (pp);
3329 : }
3330 : }
3331 : }
3332 65843 : if (CALL_EXPR_VA_ARG_PACK (node))
3333 : {
3334 0 : if (call_expr_nargs (node) > 0)
3335 : {
3336 0 : pp_comma (pp);
3337 0 : pp_space (pp);
3338 : }
3339 0 : pp_string (pp, "__builtin_va_arg_pack ()");
3340 : }
3341 65843 : pp_right_paren (pp);
3342 :
3343 65843 : op1 = CALL_EXPR_STATIC_CHAIN (node);
3344 65843 : if (op1)
3345 : {
3346 0 : pp_string (pp, " [static-chain: ");
3347 0 : dump_generic_node (pp, op1, spc, flags, false);
3348 0 : pp_right_bracket (pp);
3349 : }
3350 :
3351 65843 : if (CALL_EXPR_RETURN_SLOT_OPT (node))
3352 0 : pp_string (pp, " [return slot optimization]");
3353 65843 : if (CALL_EXPR_TAILCALL (node))
3354 0 : pp_string (pp, " [tail call]");
3355 65843 : if (CALL_EXPR_MUST_TAIL_CALL (node))
3356 0 : pp_string (pp, " [must tail call]");
3357 : break;
3358 :
3359 0 : case WITH_CLEANUP_EXPR:
3360 0 : NIY;
3361 0 : break;
3362 :
3363 16820 : case CLEANUP_POINT_EXPR:
3364 16820 : pp_string (pp, "<<cleanup_point ");
3365 16820 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3366 16820 : pp_string (pp, ">>");
3367 16820 : break;
3368 :
3369 0 : case PLACEHOLDER_EXPR:
3370 0 : pp_string (pp, "<PLACEHOLDER_EXPR ");
3371 0 : dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
3372 0 : pp_greater (pp);
3373 0 : break;
3374 :
3375 : /* Binary arithmetic and logic expressions. */
3376 252844 : case WIDEN_SUM_EXPR:
3377 252844 : case WIDEN_MULT_EXPR:
3378 252844 : case MULT_EXPR:
3379 252844 : case MULT_HIGHPART_EXPR:
3380 252844 : case PLUS_EXPR:
3381 252844 : case POINTER_PLUS_EXPR:
3382 252844 : case POINTER_DIFF_EXPR:
3383 252844 : case MINUS_EXPR:
3384 252844 : case TRUNC_DIV_EXPR:
3385 252844 : case CEIL_DIV_EXPR:
3386 252844 : case FLOOR_DIV_EXPR:
3387 252844 : case ROUND_DIV_EXPR:
3388 252844 : case TRUNC_MOD_EXPR:
3389 252844 : case CEIL_MOD_EXPR:
3390 252844 : case FLOOR_MOD_EXPR:
3391 252844 : case ROUND_MOD_EXPR:
3392 252844 : case RDIV_EXPR:
3393 252844 : case EXACT_DIV_EXPR:
3394 252844 : case LSHIFT_EXPR:
3395 252844 : case RSHIFT_EXPR:
3396 252844 : case LROTATE_EXPR:
3397 252844 : case RROTATE_EXPR:
3398 252844 : case WIDEN_LSHIFT_EXPR:
3399 252844 : case BIT_IOR_EXPR:
3400 252844 : case BIT_XOR_EXPR:
3401 252844 : case BIT_AND_EXPR:
3402 252844 : case TRUTH_ANDIF_EXPR:
3403 252844 : case TRUTH_ORIF_EXPR:
3404 252844 : case TRUTH_AND_EXPR:
3405 252844 : case TRUTH_OR_EXPR:
3406 252844 : case TRUTH_XOR_EXPR:
3407 252844 : case LT_EXPR:
3408 252844 : case LE_EXPR:
3409 252844 : case GT_EXPR:
3410 252844 : case GE_EXPR:
3411 252844 : case EQ_EXPR:
3412 252844 : case NE_EXPR:
3413 252844 : case UNLT_EXPR:
3414 252844 : case UNLE_EXPR:
3415 252844 : case UNGT_EXPR:
3416 252844 : case UNGE_EXPR:
3417 252844 : case UNEQ_EXPR:
3418 252844 : case LTGT_EXPR:
3419 252844 : case ORDERED_EXPR:
3420 252844 : case UNORDERED_EXPR:
3421 252844 : {
3422 505688 : const char *op = op_symbol (node);
3423 252844 : op0 = TREE_OPERAND (node, 0);
3424 252844 : op1 = TREE_OPERAND (node, 1);
3425 :
3426 : /* When the operands are expressions with less priority,
3427 : keep semantics of the tree representation. */
3428 252844 : if (op_prio (op0) <= op_prio (node))
3429 : {
3430 34609 : pp_left_paren (pp);
3431 34609 : dump_generic_node (pp, op0, spc, flags, false);
3432 34609 : pp_right_paren (pp);
3433 : }
3434 : else
3435 218235 : dump_generic_node (pp, op0, spc, flags, false);
3436 :
3437 252844 : pp_space (pp);
3438 252844 : pp_string (pp, op);
3439 252844 : pp_space (pp);
3440 :
3441 : /* When the operands are expressions with less priority,
3442 : keep semantics of the tree representation. */
3443 252844 : if (op_prio (op1) <= op_prio (node))
3444 : {
3445 3108 : pp_left_paren (pp);
3446 3108 : dump_generic_node (pp, op1, spc, flags, false);
3447 3108 : pp_right_paren (pp);
3448 : }
3449 : else
3450 249736 : dump_generic_node (pp, op1, spc, flags, false);
3451 : }
3452 : break;
3453 :
3454 : /* Unary arithmetic and logic expressions. */
3455 326049 : case ADDR_EXPR:
3456 326049 : if (flags & TDF_GIMPLE_VAL)
3457 : {
3458 0 : pp_string (pp, "_Literal (");
3459 0 : dump_generic_node (pp, TREE_TYPE (node), spc,
3460 : flags & ~TDF_GIMPLE_VAL, false);
3461 0 : pp_character (pp, ')');
3462 : }
3463 : /* Fallthru. */
3464 352986 : case NEGATE_EXPR:
3465 352986 : case BIT_NOT_EXPR:
3466 352986 : case TRUTH_NOT_EXPR:
3467 352986 : case PREDECREMENT_EXPR:
3468 352986 : case PREINCREMENT_EXPR:
3469 352986 : case INDIRECT_REF:
3470 352986 : if (!(flags & TDF_GIMPLE)
3471 352986 : && TREE_CODE (node) == ADDR_EXPR
3472 679035 : && (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST
3473 319257 : || TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL))
3474 : /* Do not output '&' for strings and function pointers when not
3475 : dumping GIMPLE FE syntax. */
3476 : ;
3477 : else
3478 336413 : pp_string (pp, op_symbol (node));
3479 :
3480 352986 : if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
3481 : {
3482 4909 : pp_left_paren (pp);
3483 4909 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3484 4909 : pp_right_paren (pp);
3485 : }
3486 : else
3487 348077 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3488 : break;
3489 :
3490 1523 : case POSTDECREMENT_EXPR:
3491 1523 : case POSTINCREMENT_EXPR:
3492 1523 : if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
3493 : {
3494 0 : pp_left_paren (pp);
3495 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3496 0 : pp_right_paren (pp);
3497 : }
3498 : else
3499 1523 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3500 3046 : pp_string (pp, op_symbol (node));
3501 1523 : break;
3502 :
3503 266 : case MIN_EXPR:
3504 266 : pp_string (pp, "MIN_EXPR <");
3505 266 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3506 266 : pp_string (pp, ", ");
3507 266 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3508 266 : pp_greater (pp);
3509 266 : break;
3510 :
3511 5999 : case MAX_EXPR:
3512 5999 : pp_string (pp, "MAX_EXPR <");
3513 5999 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3514 5999 : pp_string (pp, ", ");
3515 5999 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3516 5999 : pp_greater (pp);
3517 5999 : break;
3518 :
3519 511 : case ABS_EXPR:
3520 511 : pp_string (pp, "ABS_EXPR <");
3521 511 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3522 511 : pp_greater (pp);
3523 511 : break;
3524 :
3525 24 : case ABSU_EXPR:
3526 24 : pp_string (pp, "ABSU_EXPR <");
3527 24 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3528 24 : pp_greater (pp);
3529 24 : break;
3530 :
3531 0 : case RANGE_EXPR:
3532 0 : NIY;
3533 0 : break;
3534 :
3535 177323 : case ADDR_SPACE_CONVERT_EXPR:
3536 177323 : case FIXED_CONVERT_EXPR:
3537 177323 : case FIX_TRUNC_EXPR:
3538 177323 : case FLOAT_EXPR:
3539 177323 : CASE_CONVERT:
3540 177323 : type = TREE_TYPE (node);
3541 177323 : op0 = TREE_OPERAND (node, 0);
3542 177323 : if (type != TREE_TYPE (op0))
3543 : {
3544 177301 : pp_left_paren (pp);
3545 177301 : dump_generic_node (pp, type, spc, flags, false);
3546 177301 : pp_string (pp, ") ");
3547 : }
3548 177323 : if (op_prio (op0) < op_prio (node))
3549 38735 : pp_left_paren (pp);
3550 177323 : dump_generic_node (pp, op0, spc, flags, false);
3551 177323 : if (op_prio (op0) < op_prio (node))
3552 38735 : pp_right_paren (pp);
3553 : break;
3554 :
3555 38285 : case VIEW_CONVERT_EXPR:
3556 38285 : if (flags & TDF_GIMPLE)
3557 0 : pp_string (pp, "__VIEW_CONVERT <");
3558 : else
3559 38285 : pp_string (pp, "VIEW_CONVERT_EXPR<");
3560 38285 : dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
3561 38285 : pp_string (pp, ">(");
3562 38285 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3563 38285 : pp_right_paren (pp);
3564 38285 : break;
3565 :
3566 14 : case PAREN_EXPR:
3567 14 : pp_string (pp, "((");
3568 14 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3569 14 : pp_string (pp, "))");
3570 14 : break;
3571 :
3572 16564 : case NON_LVALUE_EXPR:
3573 16564 : pp_string (pp, "NON_LVALUE_EXPR <");
3574 16564 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3575 16564 : pp_greater (pp);
3576 16564 : break;
3577 :
3578 1582 : case SAVE_EXPR:
3579 1582 : pp_string (pp, "SAVE_EXPR <");
3580 1582 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3581 1582 : pp_greater (pp);
3582 1582 : break;
3583 :
3584 20 : case COMPLEX_EXPR:
3585 20 : pp_string (pp, "COMPLEX_EXPR <");
3586 20 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3587 20 : pp_string (pp, ", ");
3588 20 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3589 20 : pp_greater (pp);
3590 20 : break;
3591 :
3592 0 : case CONJ_EXPR:
3593 0 : pp_string (pp, "CONJ_EXPR <");
3594 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3595 0 : pp_greater (pp);
3596 0 : break;
3597 :
3598 50519 : case REALPART_EXPR:
3599 50519 : if (flags & TDF_GIMPLE)
3600 : {
3601 1 : pp_string (pp, "__real ");
3602 1 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3603 : }
3604 : else
3605 : {
3606 50518 : pp_string (pp, "REALPART_EXPR <");
3607 50518 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3608 50518 : pp_greater (pp);
3609 : }
3610 : break;
3611 :
3612 40762 : case IMAGPART_EXPR:
3613 40762 : if (flags & TDF_GIMPLE)
3614 : {
3615 1 : pp_string (pp, "__imag ");
3616 1 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3617 : }
3618 : else
3619 : {
3620 40761 : pp_string (pp, "IMAGPART_EXPR <");
3621 40761 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3622 40761 : pp_greater (pp);
3623 : }
3624 : break;
3625 :
3626 0 : case VA_ARG_EXPR:
3627 0 : pp_string (pp, "VA_ARG_EXPR <");
3628 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3629 0 : pp_greater (pp);
3630 0 : break;
3631 :
3632 1609 : case TRY_FINALLY_EXPR:
3633 1609 : case TRY_CATCH_EXPR:
3634 1609 : pp_string (pp, "try");
3635 1609 : newline_and_indent (pp, spc+2);
3636 1609 : pp_left_brace (pp);
3637 1609 : newline_and_indent (pp, spc+4);
3638 1609 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc+4, flags, true);
3639 1609 : newline_and_indent (pp, spc+2);
3640 1609 : pp_right_brace (pp);
3641 1609 : newline_and_indent (pp, spc);
3642 1609 : if (TREE_CODE (node) == TRY_CATCH_EXPR)
3643 : {
3644 79 : node = TREE_OPERAND (node, 1);
3645 79 : pp_string (pp, "catch");
3646 : }
3647 : else
3648 : {
3649 1530 : gcc_assert (TREE_CODE (node) == TRY_FINALLY_EXPR);
3650 1530 : node = TREE_OPERAND (node, 1);
3651 1530 : pp_string (pp, "finally");
3652 1530 : if (TREE_CODE (node) == EH_ELSE_EXPR)
3653 : {
3654 0 : newline_and_indent (pp, spc+2);
3655 0 : pp_left_brace (pp);
3656 0 : newline_and_indent (pp, spc+4);
3657 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc+4,
3658 : flags, true);
3659 0 : newline_and_indent (pp, spc+2);
3660 0 : pp_right_brace (pp);
3661 0 : newline_and_indent (pp, spc);
3662 0 : node = TREE_OPERAND (node, 1);
3663 0 : pp_string (pp, "else");
3664 : }
3665 : }
3666 1609 : newline_and_indent (pp, spc+2);
3667 1609 : pp_left_brace (pp);
3668 1609 : newline_and_indent (pp, spc+4);
3669 1609 : dump_generic_node (pp, node, spc+4, flags, true);
3670 1609 : newline_and_indent (pp, spc+2);
3671 1609 : pp_right_brace (pp);
3672 1609 : is_expr = false;
3673 1609 : break;
3674 :
3675 0 : case CATCH_EXPR:
3676 0 : pp_string (pp, "catch (");
3677 0 : dump_generic_node (pp, CATCH_TYPES (node), spc+2, flags, false);
3678 0 : pp_right_paren (pp);
3679 0 : newline_and_indent (pp, spc+2);
3680 0 : pp_left_brace (pp);
3681 0 : newline_and_indent (pp, spc+4);
3682 0 : dump_generic_node (pp, CATCH_BODY (node), spc+4, flags, true);
3683 0 : newline_and_indent (pp, spc+2);
3684 0 : pp_right_brace (pp);
3685 0 : is_expr = false;
3686 0 : break;
3687 :
3688 0 : case EH_FILTER_EXPR:
3689 0 : pp_string (pp, "<<<eh_filter (");
3690 0 : dump_generic_node (pp, EH_FILTER_TYPES (node), spc+2, flags, false);
3691 0 : pp_string (pp, ")>>>");
3692 0 : newline_and_indent (pp, spc+2);
3693 0 : pp_left_brace (pp);
3694 0 : newline_and_indent (pp, spc+4);
3695 0 : dump_generic_node (pp, EH_FILTER_FAILURE (node), spc+4, flags, true);
3696 0 : newline_and_indent (pp, spc+2);
3697 0 : pp_right_brace (pp);
3698 0 : is_expr = false;
3699 0 : break;
3700 :
3701 32306 : case LABEL_EXPR:
3702 32306 : op0 = TREE_OPERAND (node, 0);
3703 : /* If this is for break or continue, don't bother printing it. */
3704 32306 : if (DECL_NAME (op0))
3705 : {
3706 27793 : const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
3707 27793 : if (strcmp (name, "break") == 0
3708 27793 : || strcmp (name, "continue") == 0)
3709 : break;
3710 : }
3711 32306 : dump_generic_node (pp, op0, spc, flags, false);
3712 32306 : pp_colon (pp);
3713 32306 : if (DECL_NONLOCAL (op0))
3714 0 : pp_string (pp, " [non-local]");
3715 : break;
3716 :
3717 10417 : case LOOP_EXPR:
3718 10417 : pp_string (pp, "while (1)");
3719 10417 : if (!(flags & TDF_SLIM))
3720 : {
3721 10417 : newline_and_indent (pp, spc+2);
3722 10417 : pp_left_brace (pp);
3723 10417 : newline_and_indent (pp, spc+4);
3724 10417 : dump_generic_node (pp, LOOP_EXPR_BODY (node), spc+4, flags, true);
3725 10417 : newline_and_indent (pp, spc+2);
3726 10417 : pp_right_brace (pp);
3727 : }
3728 : is_expr = false;
3729 : break;
3730 :
3731 26 : case PREDICT_EXPR:
3732 26 : pp_string (pp, "// predicted ");
3733 26 : if (PREDICT_EXPR_OUTCOME (node))
3734 7 : pp_string (pp, "likely by ");
3735 : else
3736 19 : pp_string (pp, "unlikely by ");
3737 26 : pp_string (pp, predictor_name (PREDICT_EXPR_PREDICTOR (node)));
3738 26 : pp_string (pp, " predictor.");
3739 26 : break;
3740 :
3741 52 : case ANNOTATE_EXPR:
3742 52 : pp_string (pp, "ANNOTATE_EXPR <");
3743 52 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3744 52 : switch ((enum annot_expr_kind) TREE_INT_CST_LOW (TREE_OPERAND (node, 1)))
3745 : {
3746 44 : case annot_expr_ivdep_kind:
3747 44 : pp_string (pp, ", ivdep");
3748 44 : break;
3749 2 : case annot_expr_unroll_kind:
3750 2 : {
3751 2 : pp_string (pp, ", unroll ");
3752 2 : pp_decimal_int (pp,
3753 : (int) TREE_INT_CST_LOW (TREE_OPERAND (node, 2)));
3754 2 : break;
3755 : }
3756 3 : case annot_expr_no_vector_kind:
3757 3 : pp_string (pp, ", no-vector");
3758 3 : break;
3759 3 : case annot_expr_vector_kind:
3760 3 : pp_string (pp, ", vector");
3761 3 : break;
3762 0 : case annot_expr_parallel_kind:
3763 0 : pp_string (pp, ", parallel");
3764 0 : break;
3765 0 : case annot_expr_maybe_infinite_kind:
3766 0 : pp_string (pp, ", maybe-infinite");
3767 0 : break;
3768 0 : default:
3769 0 : gcc_unreachable ();
3770 : }
3771 52 : pp_greater (pp);
3772 52 : break;
3773 :
3774 9643 : case RETURN_EXPR:
3775 9643 : pp_string (pp, "return");
3776 9643 : op0 = TREE_OPERAND (node, 0);
3777 9643 : if (op0)
3778 : {
3779 9486 : pp_space (pp);
3780 9486 : if (TREE_CODE (op0) == MODIFY_EXPR)
3781 2746 : dump_generic_node (pp, TREE_OPERAND (op0, 1),
3782 : spc, flags, false);
3783 : else
3784 6740 : dump_generic_node (pp, op0, spc, flags, false);
3785 : }
3786 : break;
3787 :
3788 0 : case EXIT_EXPR:
3789 0 : pp_string (pp, "if (");
3790 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3791 0 : pp_string (pp, ") break");
3792 0 : break;
3793 :
3794 66 : case SWITCH_EXPR:
3795 66 : pp_string (pp, "switch (");
3796 66 : dump_generic_node (pp, SWITCH_COND (node), spc, flags, false);
3797 66 : pp_right_paren (pp);
3798 66 : if (!(flags & TDF_SLIM))
3799 : {
3800 66 : newline_and_indent (pp, spc+2);
3801 66 : pp_left_brace (pp);
3802 66 : if (SWITCH_BODY (node))
3803 : {
3804 66 : newline_and_indent (pp, spc+4);
3805 66 : dump_generic_node (pp, SWITCH_BODY (node), spc+4, flags,
3806 : true);
3807 : }
3808 66 : newline_and_indent (pp, spc+2);
3809 66 : pp_right_brace (pp);
3810 : }
3811 : is_expr = false;
3812 : break;
3813 :
3814 22285 : case GOTO_EXPR:
3815 22285 : op0 = GOTO_DESTINATION (node);
3816 22285 : if (TREE_CODE (op0) != SSA_NAME && DECL_P (op0) && DECL_NAME (op0))
3817 : {
3818 17500 : const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
3819 17500 : if (strcmp (name, "break") == 0
3820 17500 : || strcmp (name, "continue") == 0)
3821 : {
3822 0 : pp_string (pp, name);
3823 0 : break;
3824 : }
3825 : }
3826 22285 : pp_string (pp, "goto ");
3827 22285 : dump_generic_node (pp, op0, spc, flags, false);
3828 22285 : break;
3829 :
3830 292 : case ASM_EXPR:
3831 292 : pp_string (pp, "__asm__");
3832 292 : if (ASM_VOLATILE_P (node))
3833 292 : pp_string (pp, " __volatile__");
3834 292 : pp_left_paren (pp);
3835 292 : dump_generic_node (pp, ASM_STRING (node), spc, flags, false);
3836 292 : pp_colon (pp);
3837 292 : dump_generic_node (pp, ASM_OUTPUTS (node), spc, flags, false);
3838 292 : pp_colon (pp);
3839 292 : dump_generic_node (pp, ASM_INPUTS (node), spc, flags, false);
3840 292 : if (ASM_CLOBBERS (node))
3841 : {
3842 292 : pp_colon (pp);
3843 292 : dump_generic_node (pp, ASM_CLOBBERS (node), spc, flags, false);
3844 : }
3845 292 : pp_right_paren (pp);
3846 292 : break;
3847 :
3848 8945 : case CASE_LABEL_EXPR:
3849 8945 : if (CASE_LOW (node) && CASE_HIGH (node))
3850 : {
3851 121 : pp_string (pp, "case ");
3852 121 : dump_generic_node (pp, CASE_LOW (node), spc, flags, false);
3853 121 : pp_string (pp, " ... ");
3854 121 : dump_generic_node (pp, CASE_HIGH (node), spc, flags, false);
3855 : }
3856 8824 : else if (CASE_LOW (node))
3857 : {
3858 7289 : pp_string (pp, "case ");
3859 7289 : dump_generic_node (pp, CASE_LOW (node), spc, flags, false);
3860 : }
3861 : else
3862 1535 : pp_string (pp, "default");
3863 8945 : pp_colon (pp);
3864 8945 : break;
3865 :
3866 1782 : case OBJ_TYPE_REF:
3867 1782 : pp_string (pp, "OBJ_TYPE_REF(");
3868 1782 : dump_generic_node (pp, OBJ_TYPE_REF_EXPR (node), spc, flags, false);
3869 1782 : pp_semicolon (pp);
3870 : /* We omit the class type for -fcompare-debug because we may
3871 : drop TYPE_BINFO early depending on debug info, and then
3872 : virtual_method_call_p would return false, whereas when
3873 : TYPE_BINFO is preserved it may still return true and then
3874 : we'd print the class type. Compare tree and rtl dumps for
3875 : libstdc++-prettyprinters/shared_ptr.cc with and without -g,
3876 : for example, at occurrences of OBJ_TYPE_REF. */
3877 1782 : if (!(flags & (TDF_SLIM | TDF_COMPARE_DEBUG))
3878 1782 : && virtual_method_call_p (node, true))
3879 : {
3880 1479 : pp_string (pp, "(");
3881 1479 : dump_generic_node (pp, obj_type_ref_class (node, true),
3882 : spc, flags, false);
3883 1479 : pp_string (pp, ")");
3884 : }
3885 1782 : dump_generic_node (pp, OBJ_TYPE_REF_OBJECT (node), spc, flags, false);
3886 1782 : pp_arrow (pp);
3887 1782 : dump_generic_node (pp, OBJ_TYPE_REF_TOKEN (node), spc, flags, false);
3888 1782 : pp_right_paren (pp);
3889 1782 : break;
3890 :
3891 16067993 : case SSA_NAME:
3892 16067993 : if (SSA_NAME_IDENTIFIER (node))
3893 : {
3894 8855346 : if ((flags & TDF_NOUID)
3895 7609 : && SSA_NAME_VAR (node)
3896 8860080 : && DECL_NAMELESS (SSA_NAME_VAR (node)))
3897 1268 : dump_fancy_name (pp, SSA_NAME_IDENTIFIER (node));
3898 8854078 : else if (! (flags & TDF_GIMPLE)
3899 8854078 : || SSA_NAME_VAR (node))
3900 8854078 : dump_generic_node (pp, SSA_NAME_IDENTIFIER (node),
3901 : spc, flags, false);
3902 : }
3903 16067993 : pp_underscore (pp);
3904 16067993 : pp_decimal_int (pp, SSA_NAME_VERSION (node));
3905 16067993 : if (SSA_NAME_IS_DEFAULT_DEF (node))
3906 695879 : pp_string (pp, "(D)");
3907 16067993 : if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))
3908 366 : pp_string (pp, "(ab)");
3909 : break;
3910 :
3911 0 : case WITH_SIZE_EXPR:
3912 0 : pp_string (pp, "WITH_SIZE_EXPR <");
3913 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3914 0 : pp_string (pp, ", ");
3915 0 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3916 0 : pp_greater (pp);
3917 0 : break;
3918 :
3919 0 : case SCEV_KNOWN:
3920 0 : pp_string (pp, "scev_known");
3921 0 : break;
3922 :
3923 4785 : case SCEV_NOT_KNOWN:
3924 4785 : pp_string (pp, "scev_not_known");
3925 4785 : break;
3926 :
3927 148054 : case POLYNOMIAL_CHREC:
3928 148054 : pp_left_brace (pp);
3929 148054 : dump_generic_node (pp, CHREC_LEFT (node), spc, flags, false);
3930 148054 : pp_string (pp, ", +, ");
3931 148054 : dump_generic_node (pp, CHREC_RIGHT (node), spc, flags, false);
3932 191547 : pp_string (pp, !CHREC_NOWRAP (node) ? "}_" : "}<nw>_");
3933 148054 : pp_scalar (pp, "%u", CHREC_VARIABLE (node));
3934 148054 : is_stmt = false;
3935 148054 : break;
3936 :
3937 0 : case REALIGN_LOAD_EXPR:
3938 0 : pp_string (pp, "REALIGN_LOAD <");
3939 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3940 0 : pp_string (pp, ", ");
3941 0 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3942 0 : pp_string (pp, ", ");
3943 0 : dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
3944 0 : pp_greater (pp);
3945 0 : break;
3946 :
3947 0 : case VEC_COND_EXPR:
3948 0 : pp_string (pp, " VEC_COND_EXPR < ");
3949 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3950 0 : pp_string (pp, " , ");
3951 0 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3952 0 : pp_string (pp, " , ");
3953 0 : dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
3954 0 : pp_string (pp, " > ");
3955 0 : break;
3956 :
3957 0 : case VEC_PERM_EXPR:
3958 0 : pp_string (pp, " VEC_PERM_EXPR < ");
3959 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3960 0 : pp_string (pp, " , ");
3961 0 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3962 0 : pp_string (pp, " , ");
3963 0 : dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
3964 0 : pp_string (pp, " > ");
3965 0 : break;
3966 :
3967 0 : case DOT_PROD_EXPR:
3968 0 : pp_string (pp, " DOT_PROD_EXPR < ");
3969 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3970 0 : pp_string (pp, ", ");
3971 0 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3972 0 : pp_string (pp, ", ");
3973 0 : dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
3974 0 : pp_string (pp, " > ");
3975 0 : break;
3976 :
3977 0 : case WIDEN_MULT_PLUS_EXPR:
3978 0 : pp_string (pp, " WIDEN_MULT_PLUS_EXPR < ");
3979 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3980 0 : pp_string (pp, ", ");
3981 0 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3982 0 : pp_string (pp, ", ");
3983 0 : dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
3984 0 : pp_string (pp, " > ");
3985 0 : break;
3986 :
3987 0 : case WIDEN_MULT_MINUS_EXPR:
3988 0 : pp_string (pp, " WIDEN_MULT_MINUS_EXPR < ");
3989 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3990 0 : pp_string (pp, ", ");
3991 0 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3992 0 : pp_string (pp, ", ");
3993 0 : dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
3994 0 : pp_string (pp, " > ");
3995 0 : break;
3996 :
3997 117 : case OACC_PARALLEL:
3998 117 : pp_string (pp, "#pragma acc parallel");
3999 117 : goto dump_omp_clauses_body;
4000 :
4001 57 : case OACC_KERNELS:
4002 57 : pp_string (pp, "#pragma acc kernels");
4003 57 : goto dump_omp_clauses_body;
4004 :
4005 58 : case OACC_SERIAL:
4006 58 : pp_string (pp, "#pragma acc serial");
4007 58 : goto dump_omp_clauses_body;
4008 :
4009 21 : case OACC_DATA:
4010 21 : pp_string (pp, "#pragma acc data");
4011 21 : dump_omp_clauses (pp, OACC_DATA_CLAUSES (node), spc, flags);
4012 21 : goto dump_omp_body;
4013 :
4014 35 : case OACC_HOST_DATA:
4015 35 : pp_string (pp, "#pragma acc host_data");
4016 35 : dump_omp_clauses (pp, OACC_HOST_DATA_CLAUSES (node), spc, flags);
4017 35 : goto dump_omp_body;
4018 :
4019 4 : case OACC_DECLARE:
4020 4 : pp_string (pp, "#pragma acc declare");
4021 4 : dump_omp_clauses (pp, OACC_DECLARE_CLAUSES (node), spc, flags);
4022 4 : break;
4023 :
4024 0 : case OACC_UPDATE:
4025 0 : pp_string (pp, "#pragma acc update");
4026 0 : dump_omp_clauses (pp, OACC_UPDATE_CLAUSES (node), spc, flags);
4027 0 : break;
4028 :
4029 13 : case OACC_ENTER_DATA:
4030 13 : pp_string (pp, "#pragma acc enter data");
4031 13 : dump_omp_clauses (pp, OACC_ENTER_DATA_CLAUSES (node), spc, flags);
4032 13 : break;
4033 :
4034 38 : case OACC_EXIT_DATA:
4035 38 : pp_string (pp, "#pragma acc exit data");
4036 38 : dump_omp_clauses (pp, OACC_EXIT_DATA_CLAUSES (node), spc, flags);
4037 38 : break;
4038 :
4039 48 : case OACC_CACHE:
4040 48 : pp_string (pp, "#pragma acc cache");
4041 48 : dump_omp_clauses (pp, OACC_CACHE_CLAUSES (node), spc, flags);
4042 48 : break;
4043 :
4044 217 : case OMP_PARALLEL:
4045 217 : pp_string (pp, "#pragma omp parallel");
4046 217 : dump_omp_clauses (pp, OMP_PARALLEL_CLAUSES (node), spc, flags);
4047 217 : goto dump_omp_body;
4048 :
4049 232 : dump_omp_clauses_body:
4050 232 : dump_omp_clauses (pp, OMP_CLAUSES (node), spc, flags);
4051 232 : goto dump_omp_body;
4052 :
4053 1461 : dump_omp_body:
4054 1461 : if (!(flags & TDF_SLIM) && OMP_BODY (node))
4055 : {
4056 1460 : newline_and_indent (pp, spc + 2);
4057 1460 : pp_left_brace (pp);
4058 1460 : newline_and_indent (pp, spc + 4);
4059 1460 : dump_generic_node (pp, OMP_BODY (node), spc + 4, flags, false);
4060 1460 : newline_and_indent (pp, spc + 2);
4061 1460 : pp_right_brace (pp);
4062 : }
4063 : is_expr = false;
4064 : break;
4065 :
4066 161 : case OMP_TASK:
4067 162 : pp_string (pp, OMP_TASK_BODY (node) ? "#pragma omp task"
4068 : : "#pragma omp taskwait");
4069 161 : dump_omp_clauses (pp, OMP_TASK_CLAUSES (node), spc, flags);
4070 161 : goto dump_omp_body;
4071 :
4072 242 : case OMP_FOR:
4073 242 : pp_string (pp, "#pragma omp for");
4074 242 : goto dump_omp_loop;
4075 :
4076 209 : case OMP_SIMD:
4077 209 : pp_string (pp, "#pragma omp simd");
4078 209 : goto dump_omp_loop;
4079 :
4080 50 : case OMP_DISTRIBUTE:
4081 50 : pp_string (pp, "#pragma omp distribute");
4082 50 : goto dump_omp_loop;
4083 :
4084 5 : case OMP_TASKLOOP:
4085 5 : pp_string (pp, "#pragma omp taskloop");
4086 5 : goto dump_omp_loop;
4087 :
4088 21 : case OMP_LOOP:
4089 21 : pp_string (pp, "#pragma omp loop");
4090 21 : goto dump_omp_loop;
4091 :
4092 188 : case OMP_TILE:
4093 188 : pp_string (pp, "#pragma omp tile");
4094 188 : goto dump_omp_loop;
4095 :
4096 196 : case OMP_UNROLL:
4097 196 : pp_string (pp, "#pragma omp unroll");
4098 196 : goto dump_omp_loop;
4099 :
4100 307 : case OACC_LOOP:
4101 307 : pp_string (pp, "#pragma acc loop");
4102 307 : goto dump_omp_loop;
4103 :
4104 75 : case OMP_TEAMS:
4105 75 : pp_string (pp, "#pragma omp teams");
4106 75 : dump_omp_clauses (pp, OMP_TEAMS_CLAUSES (node), spc, flags);
4107 75 : goto dump_omp_body;
4108 :
4109 69 : case OMP_TARGET_DATA:
4110 69 : pp_string (pp, "#pragma omp target data");
4111 69 : dump_omp_clauses (pp, OMP_TARGET_DATA_CLAUSES (node), spc, flags);
4112 69 : goto dump_omp_body;
4113 :
4114 70 : case OMP_TARGET_ENTER_DATA:
4115 70 : pp_string (pp, "#pragma omp target enter data");
4116 70 : dump_omp_clauses (pp, OMP_TARGET_ENTER_DATA_CLAUSES (node), spc, flags);
4117 70 : is_expr = false;
4118 70 : break;
4119 :
4120 56 : case OMP_TARGET_EXIT_DATA:
4121 56 : pp_string (pp, "#pragma omp target exit data");
4122 56 : dump_omp_clauses (pp, OMP_TARGET_EXIT_DATA_CLAUSES (node), spc, flags);
4123 56 : is_expr = false;
4124 56 : break;
4125 :
4126 477 : case OMP_TARGET:
4127 477 : pp_string (pp, "#pragma omp target");
4128 477 : dump_omp_clauses (pp, OMP_TARGET_CLAUSES (node), spc, flags);
4129 477 : goto dump_omp_body;
4130 :
4131 41 : case OMP_TARGET_UPDATE:
4132 41 : pp_string (pp, "#pragma omp target update");
4133 41 : dump_omp_clauses (pp, OMP_TARGET_UPDATE_CLAUSES (node), spc, flags);
4134 41 : is_expr = false;
4135 41 : break;
4136 :
4137 1218 : dump_omp_loop:
4138 1218 : dump_omp_clauses (pp, OMP_FOR_CLAUSES (node), spc, flags);
4139 1218 : if (!(flags & TDF_SLIM))
4140 : {
4141 1218 : int i;
4142 :
4143 1218 : if (OMP_FOR_PRE_BODY (node))
4144 : {
4145 366 : newline_and_indent (pp, spc + 2);
4146 366 : pp_left_brace (pp);
4147 366 : spc += 4;
4148 366 : newline_and_indent (pp, spc);
4149 366 : dump_generic_node (pp, OMP_FOR_PRE_BODY (node),
4150 : spc, flags, false);
4151 : }
4152 1218 : if (OMP_FOR_INIT (node))
4153 : {
4154 1122 : spc -= 2;
4155 2502 : for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (node)); i++)
4156 : {
4157 1380 : if (TREE_VEC_ELT (OMP_FOR_INIT (node), i) == NULL_TREE)
4158 297 : continue;
4159 1083 : spc += 2;
4160 1083 : newline_and_indent (pp, spc);
4161 1083 : pp_string (pp, "for (");
4162 1083 : tree init = TREE_VEC_ELT (OMP_FOR_INIT (node), i);
4163 1083 : if (TREE_CODE (init) != MODIFY_EXPR
4164 1083 : || TREE_CODE (TREE_OPERAND (init, 1)) != TREE_VEC)
4165 1036 : dump_generic_node (pp, init, spc, flags, false);
4166 : else
4167 : {
4168 47 : dump_generic_node (pp, TREE_OPERAND (init, 0),
4169 : spc, flags, false);
4170 47 : pp_string (pp, " = ");
4171 47 : dump_omp_loop_non_rect_expr (pp, TREE_OPERAND (init, 1),
4172 : spc, flags);
4173 : }
4174 1083 : pp_string (pp, "; ");
4175 1083 : tree cond = TREE_VEC_ELT (OMP_FOR_COND (node), i);
4176 1083 : if (!COMPARISON_CLASS_P (cond)
4177 1083 : || TREE_CODE (TREE_OPERAND (cond, 1)) != TREE_VEC)
4178 1042 : dump_generic_node (pp, cond, spc, flags, false);
4179 : else
4180 : {
4181 41 : dump_generic_node (pp, TREE_OPERAND (cond, 0),
4182 : spc, flags, false);
4183 82 : const char *op = op_symbol (cond);
4184 41 : pp_space (pp);
4185 41 : pp_string (pp, op);
4186 41 : pp_space (pp);
4187 41 : dump_omp_loop_non_rect_expr (pp, TREE_OPERAND (cond, 1),
4188 : spc, flags);
4189 : }
4190 1083 : pp_string (pp, "; ");
4191 1083 : dump_generic_node (pp,
4192 1083 : TREE_VEC_ELT (OMP_FOR_INCR (node), i),
4193 : spc, flags, false);
4194 1083 : pp_right_paren (pp);
4195 : }
4196 : }
4197 1218 : if (OMP_FOR_BODY (node))
4198 : {
4199 1218 : newline_and_indent (pp, spc + 2);
4200 1218 : pp_left_brace (pp);
4201 1218 : newline_and_indent (pp, spc + 4);
4202 1218 : dump_generic_node (pp, OMP_FOR_BODY (node), spc + 4, flags,
4203 : false);
4204 1218 : newline_and_indent (pp, spc + 2);
4205 1218 : pp_right_brace (pp);
4206 : }
4207 1218 : if (OMP_FOR_INIT (node))
4208 1122 : spc -= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node)) - 2;
4209 1218 : if (OMP_FOR_PRE_BODY (node))
4210 : {
4211 366 : spc -= 4;
4212 366 : newline_and_indent (pp, spc + 2);
4213 366 : pp_right_brace (pp);
4214 : }
4215 : }
4216 : is_expr = false;
4217 : break;
4218 :
4219 10 : case OMP_SECTIONS:
4220 10 : pp_string (pp, "#pragma omp sections");
4221 10 : dump_omp_clauses (pp, OMP_SECTIONS_CLAUSES (node), spc, flags);
4222 10 : goto dump_omp_body;
4223 :
4224 57 : case OMP_DISPATCH:
4225 57 : pp_string (pp, "#pragma omp dispatch");
4226 57 : dump_omp_clauses (pp, OMP_DISPATCH_CLAUSES (node), spc, flags);
4227 57 : goto dump_omp_body;
4228 :
4229 65 : case OMP_INTEROP:
4230 65 : pp_string (pp, "#pragma omp interop");
4231 65 : dump_omp_clauses (pp, OMP_INTEROP_CLAUSES (node), spc, flags);
4232 65 : is_expr = false;
4233 65 : break;
4234 :
4235 14 : case OMP_SECTION:
4236 14 : pp_string (pp, "#pragma omp section");
4237 14 : goto dump_omp_body;
4238 :
4239 10 : case OMP_STRUCTURED_BLOCK:
4240 10 : pp_string (pp, "#pragma omp __structured_block");
4241 10 : goto dump_omp_body;
4242 :
4243 10 : case OMP_SCAN:
4244 10 : if (OMP_SCAN_CLAUSES (node))
4245 : {
4246 5 : pp_string (pp, "#pragma omp scan");
4247 5 : dump_omp_clauses (pp, OMP_SCAN_CLAUSES (node), spc, flags);
4248 : }
4249 10 : goto dump_omp_body;
4250 :
4251 4 : case OMP_MASTER:
4252 4 : pp_string (pp, "#pragma omp master");
4253 4 : goto dump_omp_body;
4254 :
4255 1 : case OMP_MASKED:
4256 1 : pp_string (pp, "#pragma omp masked");
4257 1 : dump_omp_clauses (pp, OMP_MASKED_CLAUSES (node), spc, flags);
4258 1 : goto dump_omp_body;
4259 :
4260 5 : case OMP_TASKGROUP:
4261 5 : pp_string (pp, "#pragma omp taskgroup");
4262 5 : dump_omp_clauses (pp, OMP_TASKGROUP_CLAUSES (node), spc, flags);
4263 5 : goto dump_omp_body;
4264 :
4265 18 : case OMP_ORDERED:
4266 18 : pp_string (pp, "#pragma omp ordered");
4267 18 : dump_omp_clauses (pp, OMP_ORDERED_CLAUSES (node), spc, flags);
4268 18 : goto dump_omp_body;
4269 :
4270 26 : case OMP_CRITICAL:
4271 26 : pp_string (pp, "#pragma omp critical");
4272 26 : if (OMP_CRITICAL_NAME (node))
4273 : {
4274 23 : pp_space (pp);
4275 23 : pp_left_paren (pp);
4276 23 : dump_generic_node (pp, OMP_CRITICAL_NAME (node), spc,
4277 : flags, false);
4278 23 : pp_right_paren (pp);
4279 : }
4280 26 : dump_omp_clauses (pp, OMP_CRITICAL_CLAUSES (node), spc, flags);
4281 26 : goto dump_omp_body;
4282 :
4283 191 : case OMP_ATOMIC:
4284 191 : pp_string (pp, "#pragma omp atomic");
4285 191 : if (OMP_ATOMIC_WEAK (node))
4286 0 : pp_string (pp, " weak");
4287 191 : dump_omp_atomic_memory_order (pp, OMP_ATOMIC_MEMORY_ORDER (node));
4288 191 : newline_and_indent (pp, spc + 2);
4289 191 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
4290 191 : pp_space (pp);
4291 191 : pp_equal (pp);
4292 191 : pp_space (pp);
4293 191 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
4294 191 : break;
4295 :
4296 42 : case OMP_ATOMIC_READ:
4297 42 : pp_string (pp, "#pragma omp atomic read");
4298 42 : dump_omp_atomic_memory_order (pp, OMP_ATOMIC_MEMORY_ORDER (node));
4299 42 : newline_and_indent (pp, spc + 2);
4300 42 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
4301 42 : pp_space (pp);
4302 42 : break;
4303 :
4304 56 : case OMP_ATOMIC_CAPTURE_OLD:
4305 56 : case OMP_ATOMIC_CAPTURE_NEW:
4306 56 : pp_string (pp, "#pragma omp atomic capture");
4307 56 : if (OMP_ATOMIC_WEAK (node))
4308 0 : pp_string (pp, " weak");
4309 56 : dump_omp_atomic_memory_order (pp, OMP_ATOMIC_MEMORY_ORDER (node));
4310 56 : newline_and_indent (pp, spc + 2);
4311 56 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
4312 56 : pp_space (pp);
4313 56 : pp_equal (pp);
4314 56 : pp_space (pp);
4315 56 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
4316 56 : break;
4317 :
4318 17 : case OMP_SINGLE:
4319 17 : pp_string (pp, "#pragma omp single");
4320 17 : dump_omp_clauses (pp, OMP_SINGLE_CLAUSES (node), spc, flags);
4321 17 : goto dump_omp_body;
4322 :
4323 2 : case OMP_SCOPE:
4324 2 : pp_string (pp, "#pragma omp scope");
4325 2 : dump_omp_clauses (pp, OMP_SCOPE_CLAUSES (node), spc, flags);
4326 2 : goto dump_omp_body;
4327 :
4328 1563 : case OMP_CLAUSE:
4329 : /* If we come here, we're dumping something that's not an OMP construct,
4330 : for example, OMP clauses attached to a function's '__attribute__'.
4331 : Dump the whole OMP clause chain. */
4332 1563 : dump_omp_clauses (pp, node, spc, flags, false);
4333 1563 : is_expr = false;
4334 1563 : break;
4335 :
4336 34 : case OMP_METADIRECTIVE:
4337 34 : {
4338 34 : pp_string (pp, "#pragma omp metadirective");
4339 34 : newline_and_indent (pp, spc + 2);
4340 34 : pp_left_brace (pp);
4341 :
4342 34 : tree variant = OMP_METADIRECTIVE_VARIANTS (node);
4343 120 : while (variant != NULL_TREE)
4344 : {
4345 86 : tree selector = OMP_METADIRECTIVE_VARIANT_SELECTOR (variant);
4346 86 : tree directive = OMP_METADIRECTIVE_VARIANT_DIRECTIVE (variant);
4347 86 : tree body = OMP_METADIRECTIVE_VARIANT_BODY (variant);
4348 :
4349 86 : newline_and_indent (pp, spc + 4);
4350 86 : if (selector == NULL_TREE)
4351 34 : pp_string (pp, "otherwise:");
4352 : else
4353 : {
4354 52 : pp_string (pp, "when (");
4355 52 : dump_omp_context_selector (pp, selector, spc + 4, flags);
4356 52 : pp_string (pp, "):");
4357 : }
4358 86 : newline_and_indent (pp, spc + 6);
4359 :
4360 86 : dump_generic_node (pp, directive, spc + 6, flags, false);
4361 86 : newline_and_indent (pp, spc + 6);
4362 86 : dump_generic_node (pp, body, spc + 6, flags, false);
4363 86 : variant = TREE_CHAIN (variant);
4364 : }
4365 34 : newline_and_indent (pp, spc + 2);
4366 34 : pp_right_brace (pp);
4367 : }
4368 34 : break;
4369 :
4370 12 : case OMP_NEXT_VARIANT:
4371 12 : {
4372 12 : pp_string (pp, "OMP_NEXT_VARIANT <");
4373 12 : dump_generic_node (pp, OMP_NEXT_VARIANT_INDEX (node), spc,
4374 : flags, false);
4375 12 : pp_string (pp, ", ");
4376 12 : tree state = OMP_NEXT_VARIANT_STATE (node);
4377 12 : gcc_assert (state && TREE_CODE (state) == TREE_LIST);
4378 12 : if (TREE_PURPOSE (state))
4379 : {
4380 0 : newline_and_indent (pp, spc + 2);
4381 0 : pp_string (pp, "resolution map = ");
4382 0 : dump_generic_node (pp, TREE_PURPOSE (state), spc, flags, false);
4383 : }
4384 12 : newline_and_indent (pp, spc + 2);
4385 12 : pp_string (pp, "construct context = ");
4386 12 : if (TREE_VALUE (state))
4387 0 : dump_generic_node (pp, TREE_VALUE (state), spc, flags, false);
4388 : else
4389 12 : pp_string (pp, "NULL");
4390 :
4391 12 : tree selectors = TREE_CHAIN (state);
4392 60 : for (int i = 0; i < TREE_VEC_LENGTH (selectors); i++)
4393 : {
4394 48 : newline_and_indent (pp, spc + 2);
4395 48 : pp_decimal_int (pp, i + 1);
4396 48 : pp_string (pp, ": ");
4397 48 : dump_omp_context_selector (pp, TREE_VEC_ELT (selectors, i),
4398 : spc + 4, flags);
4399 : }
4400 12 : pp_string (pp, ">");
4401 : }
4402 12 : break;
4403 :
4404 0 : case OMP_TARGET_DEVICE_MATCHES:
4405 0 : pp_string (pp, "OMP_TARGET_DEVICE_MATCHES <");
4406 0 : dump_generic_node (pp, OMP_TARGET_DEVICE_MATCHES_SELECTOR (node), spc,
4407 : flags, false);
4408 0 : for (tree p = OMP_TARGET_DEVICE_MATCHES_PROPERTIES (node);
4409 0 : p; p = TREE_CHAIN (p))
4410 : {
4411 0 : pp_string (pp, ", ");
4412 0 : dump_generic_node (pp, OMP_TP_VALUE (p), spc, flags, false);
4413 : }
4414 0 : pp_string (pp, ")>");
4415 0 : break;
4416 :
4417 52 : case OMP_DECLARE_MAPPER:
4418 52 : pp_string (pp, "#pragma omp declare mapper (");
4419 52 : if (OMP_DECLARE_MAPPER_ID (node))
4420 : {
4421 8 : dump_generic_node (pp, OMP_DECLARE_MAPPER_ID (node), spc, flags,
4422 : false);
4423 8 : pp_colon (pp);
4424 : }
4425 52 : dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
4426 52 : pp_space (pp);
4427 52 : dump_generic_node (pp, OMP_DECLARE_MAPPER_DECL (node), spc, flags, false);
4428 52 : pp_right_paren (pp);
4429 52 : dump_omp_clauses (pp, OMP_DECLARE_MAPPER_CLAUSES (node), spc, flags);
4430 52 : break;
4431 :
4432 0 : case TRANSACTION_EXPR:
4433 0 : if (TRANSACTION_EXPR_OUTER (node))
4434 0 : pp_string (pp, "__transaction_atomic [[outer]]");
4435 0 : else if (TRANSACTION_EXPR_RELAXED (node))
4436 0 : pp_string (pp, "__transaction_relaxed");
4437 : else
4438 0 : pp_string (pp, "__transaction_atomic");
4439 0 : if (!(flags & TDF_SLIM) && TRANSACTION_EXPR_BODY (node))
4440 : {
4441 0 : newline_and_indent (pp, spc);
4442 0 : pp_left_brace (pp);
4443 0 : newline_and_indent (pp, spc + 2);
4444 0 : dump_generic_node (pp, TRANSACTION_EXPR_BODY (node),
4445 : spc + 2, flags, false);
4446 0 : newline_and_indent (pp, spc);
4447 0 : pp_right_brace (pp);
4448 : }
4449 : is_expr = false;
4450 : break;
4451 :
4452 0 : case VEC_SERIES_EXPR:
4453 0 : case VEC_WIDEN_MULT_HI_EXPR:
4454 0 : case VEC_WIDEN_MULT_LO_EXPR:
4455 0 : case VEC_WIDEN_MULT_EVEN_EXPR:
4456 0 : case VEC_WIDEN_MULT_ODD_EXPR:
4457 0 : case VEC_WIDEN_LSHIFT_HI_EXPR:
4458 0 : case VEC_WIDEN_LSHIFT_LO_EXPR:
4459 0 : pp_space (pp);
4460 0 : for (str = get_tree_code_name (code); *str; str++)
4461 0 : pp_character (pp, TOUPPER (*str));
4462 0 : pp_string (pp, " < ");
4463 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
4464 0 : pp_string (pp, ", ");
4465 0 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
4466 0 : pp_string (pp, " > ");
4467 0 : break;
4468 :
4469 0 : case VEC_DUPLICATE_EXPR:
4470 0 : pp_space (pp);
4471 0 : for (str = get_tree_code_name (code); *str; str++)
4472 0 : pp_character (pp, TOUPPER (*str));
4473 0 : pp_string (pp, " < ");
4474 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
4475 0 : pp_string (pp, " > ");
4476 0 : break;
4477 :
4478 0 : case VEC_UNPACK_HI_EXPR:
4479 0 : pp_string (pp, " VEC_UNPACK_HI_EXPR < ");
4480 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
4481 0 : pp_string (pp, " > ");
4482 0 : break;
4483 :
4484 0 : case VEC_UNPACK_LO_EXPR:
4485 0 : pp_string (pp, " VEC_UNPACK_LO_EXPR < ");
4486 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
4487 0 : pp_string (pp, " > ");
4488 0 : break;
4489 :
4490 0 : case VEC_UNPACK_FLOAT_HI_EXPR:
4491 0 : pp_string (pp, " VEC_UNPACK_FLOAT_HI_EXPR < ");
4492 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
4493 0 : pp_string (pp, " > ");
4494 0 : break;
4495 :
4496 0 : case VEC_UNPACK_FLOAT_LO_EXPR:
4497 0 : pp_string (pp, " VEC_UNPACK_FLOAT_LO_EXPR < ");
4498 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
4499 0 : pp_string (pp, " > ");
4500 0 : break;
4501 :
4502 0 : case VEC_UNPACK_FIX_TRUNC_HI_EXPR:
4503 0 : pp_string (pp, " VEC_UNPACK_FIX_TRUNC_HI_EXPR < ");
4504 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
4505 0 : pp_string (pp, " > ");
4506 0 : break;
4507 :
4508 0 : case VEC_UNPACK_FIX_TRUNC_LO_EXPR:
4509 0 : pp_string (pp, " VEC_UNPACK_FIX_TRUNC_LO_EXPR < ");
4510 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
4511 0 : pp_string (pp, " > ");
4512 0 : break;
4513 :
4514 0 : case VEC_PACK_TRUNC_EXPR:
4515 0 : pp_string (pp, " VEC_PACK_TRUNC_EXPR < ");
4516 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
4517 0 : pp_string (pp, ", ");
4518 0 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
4519 0 : pp_string (pp, " > ");
4520 0 : break;
4521 :
4522 0 : case VEC_PACK_SAT_EXPR:
4523 0 : pp_string (pp, " VEC_PACK_SAT_EXPR < ");
4524 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
4525 0 : pp_string (pp, ", ");
4526 0 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
4527 0 : pp_string (pp, " > ");
4528 0 : break;
4529 :
4530 0 : case VEC_PACK_FIX_TRUNC_EXPR:
4531 0 : pp_string (pp, " VEC_PACK_FIX_TRUNC_EXPR < ");
4532 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
4533 0 : pp_string (pp, ", ");
4534 0 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
4535 0 : pp_string (pp, " > ");
4536 0 : break;
4537 :
4538 0 : case VEC_PACK_FLOAT_EXPR:
4539 0 : pp_string (pp, " VEC_PACK_FLOAT_EXPR < ");
4540 0 : dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
4541 0 : pp_string (pp, ", ");
4542 0 : dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
4543 0 : pp_string (pp, " > ");
4544 0 : break;
4545 :
4546 6 : case BLOCK:
4547 6 : dump_block_node (pp, node, spc, flags);
4548 6 : break;
4549 :
4550 888 : case DEBUG_BEGIN_STMT:
4551 888 : pp_string (pp, "# DEBUG BEGIN STMT");
4552 888 : break;
4553 :
4554 13277 : default:
4555 13277 : NIY;
4556 : }
4557 :
4558 46111509 : if (is_stmt && is_expr)
4559 323143 : pp_semicolon (pp);
4560 :
4561 : return spc;
4562 : }
4563 :
4564 : /* Print the declaration of a variable. */
4565 :
4566 : void
4567 444457 : print_declaration (pretty_printer *pp, tree t, int spc, dump_flags_t flags)
4568 : {
4569 2250665 : INDENT (spc);
4570 :
4571 444457 : if (TREE_CODE(t) == NAMELIST_DECL)
4572 : {
4573 1 : pp_string(pp, "namelist ");
4574 1 : dump_decl_name (pp, t, flags);
4575 1 : pp_semicolon (pp);
4576 1 : return;
4577 : }
4578 :
4579 444456 : if (TREE_CODE (t) == TYPE_DECL)
4580 1798 : pp_string (pp, "typedef ");
4581 :
4582 444456 : if (HAS_RTL_P (t) && DECL_REGISTER (t))
4583 39 : pp_string (pp, "register ");
4584 :
4585 444456 : if (TREE_PUBLIC (t) && DECL_EXTERNAL (t))
4586 5178 : pp_string (pp, "extern ");
4587 439278 : else if (TREE_STATIC (t))
4588 16700 : pp_string (pp, "static ");
4589 :
4590 : /* Print the type and name. */
4591 444456 : if (TREE_TYPE (t) && TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
4592 : {
4593 26306 : tree tmp;
4594 :
4595 : /* Print array's type. */
4596 26306 : tmp = TREE_TYPE (t);
4597 27152 : while (TREE_CODE (TREE_TYPE (tmp)) == ARRAY_TYPE)
4598 846 : tmp = TREE_TYPE (tmp);
4599 26306 : dump_generic_node (pp, TREE_TYPE (tmp), spc, flags, false);
4600 :
4601 : /* Print variable's name. */
4602 26306 : pp_space (pp);
4603 26306 : dump_generic_node (pp, t, spc, flags, false);
4604 :
4605 : /* Print the dimensions. */
4606 26306 : tmp = TREE_TYPE (t);
4607 53458 : while (TREE_CODE (tmp) == ARRAY_TYPE)
4608 : {
4609 27152 : dump_array_domain (pp, TYPE_DOMAIN (tmp), spc, flags);
4610 27152 : tmp = TREE_TYPE (tmp);
4611 : }
4612 : }
4613 418150 : else if (TREE_CODE (t) == FUNCTION_DECL)
4614 : {
4615 8873 : dump_generic_node (pp, TREE_TYPE (TREE_TYPE (t)), spc, flags, false);
4616 8873 : pp_space (pp);
4617 8873 : dump_decl_name (pp, t, flags);
4618 8873 : dump_function_declaration (pp, TREE_TYPE (t), spc, flags);
4619 : }
4620 : else
4621 : {
4622 : /* Print type declaration. */
4623 409277 : dump_generic_node (pp, TREE_TYPE (t), spc, flags, false);
4624 :
4625 : /* Print variable's name. */
4626 409277 : pp_space (pp);
4627 409277 : dump_generic_node (pp, t, spc, flags, false);
4628 : }
4629 :
4630 444456 : if (VAR_P (t) && DECL_HARD_REGISTER (t))
4631 : {
4632 5 : pp_string (pp, " __asm__ ");
4633 5 : pp_left_paren (pp);
4634 5 : dump_generic_node (pp, DECL_ASSEMBLER_NAME (t), spc, flags, false);
4635 5 : pp_right_paren (pp);
4636 : }
4637 :
4638 : /* The initial value of a function serves to determine whether the function
4639 : is declared or defined. So the following does not apply to function
4640 : nodes. */
4641 444456 : if (TREE_CODE (t) != FUNCTION_DECL)
4642 : {
4643 : /* Print the initial value. */
4644 435583 : if (DECL_INITIAL (t))
4645 : {
4646 21924 : pp_space (pp);
4647 21924 : pp_equal (pp);
4648 21924 : pp_space (pp);
4649 21924 : if (!(flags & TDF_SLIM))
4650 21144 : dump_generic_node (pp, DECL_INITIAL (t), spc, flags, false);
4651 : else
4652 780 : pp_string (pp, "<<< omitted >>>");
4653 : }
4654 : }
4655 :
4656 444456 : if (VAR_P (t) && DECL_HAS_VALUE_EXPR_P (t))
4657 : {
4658 723 : pp_string (pp, " [value-expr: ");
4659 723 : dump_generic_node (pp, DECL_VALUE_EXPR (t), spc, flags, false);
4660 723 : pp_right_bracket (pp);
4661 : }
4662 :
4663 444456 : pp_semicolon (pp);
4664 : }
4665 :
4666 :
4667 : /* Prints a structure: name, fields, and methods.
4668 : FIXME: Still incomplete. */
4669 :
4670 : static void
4671 576 : print_struct_decl (pretty_printer *pp, const_tree node, int spc,
4672 : dump_flags_t flags)
4673 : {
4674 : /* Print the name of the structure. */
4675 576 : if (TYPE_NAME (node))
4676 : {
4677 0 : INDENT (spc);
4678 0 : if (TREE_CODE (node) == RECORD_TYPE)
4679 0 : pp_string (pp, "struct ");
4680 0 : else if ((TREE_CODE (node) == UNION_TYPE
4681 0 : || TREE_CODE (node) == QUAL_UNION_TYPE))
4682 0 : pp_string (pp, "union ");
4683 :
4684 0 : dump_generic_node (pp, TYPE_NAME (node), spc, TDF_NONE, false);
4685 : }
4686 :
4687 : /* Print the contents of the structure. */
4688 576 : pp_newline (pp);
4689 1892 : INDENT (spc);
4690 576 : pp_left_brace (pp);
4691 576 : pp_newline (pp);
4692 :
4693 : /* Print the fields of the structure. */
4694 576 : {
4695 576 : tree tmp;
4696 576 : tmp = TYPE_FIELDS (node);
4697 3169 : while (tmp)
4698 : {
4699 : /* Avoid to print recursively the structure. */
4700 : /* FIXME : Not implemented correctly...,
4701 : what about the case when we have a cycle in the contain graph? ...
4702 : Maybe this could be solved by looking at the scope in which the
4703 : structure was declared. */
4704 2593 : if (TREE_TYPE (tmp) != node
4705 2593 : && (TREE_CODE (TREE_TYPE (tmp)) != POINTER_TYPE
4706 52 : || TREE_TYPE (TREE_TYPE (tmp)) != node))
4707 : {
4708 2593 : print_declaration (pp, tmp, spc+2, flags);
4709 2593 : pp_newline (pp);
4710 : }
4711 2593 : tmp = DECL_CHAIN (tmp);
4712 : }
4713 : }
4714 1316 : INDENT (spc);
4715 576 : pp_right_brace (pp);
4716 576 : }
4717 :
4718 : /* Return the priority of the operator CODE.
4719 :
4720 : From lowest to highest precedence with either left-to-right (L-R)
4721 : or right-to-left (R-L) associativity]:
4722 :
4723 : 1 [L-R] ,
4724 : 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
4725 : 3 [R-L] ?:
4726 : 4 [L-R] ||
4727 : 5 [L-R] &&
4728 : 6 [L-R] |
4729 : 7 [L-R] ^
4730 : 8 [L-R] &
4731 : 9 [L-R] == !=
4732 : 10 [L-R] < <= > >=
4733 : 11 [L-R] << >>
4734 : 12 [L-R] + -
4735 : 13 [L-R] * / %
4736 : 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
4737 : 15 [L-R] fn() [] -> .
4738 :
4739 : unary +, - and * have higher precedence than the corresponding binary
4740 : operators. */
4741 :
4742 : int
4743 21643592 : op_code_prio (enum tree_code code)
4744 : {
4745 21643592 : switch (code)
4746 : {
4747 : case TREE_LIST:
4748 : case COMPOUND_EXPR:
4749 : case BIND_EXPR:
4750 : return 1;
4751 :
4752 : case MODIFY_EXPR:
4753 : case INIT_EXPR:
4754 : return 2;
4755 :
4756 : case COND_EXPR:
4757 : return 3;
4758 :
4759 : case TRUTH_OR_EXPR:
4760 : case TRUTH_ORIF_EXPR:
4761 : return 4;
4762 :
4763 : case TRUTH_AND_EXPR:
4764 : case TRUTH_ANDIF_EXPR:
4765 : return 5;
4766 :
4767 : case BIT_IOR_EXPR:
4768 : return 6;
4769 :
4770 : case BIT_XOR_EXPR:
4771 : case TRUTH_XOR_EXPR:
4772 : return 7;
4773 :
4774 : case BIT_AND_EXPR:
4775 : return 8;
4776 :
4777 : case EQ_EXPR:
4778 : case NE_EXPR:
4779 : return 9;
4780 :
4781 : case UNLT_EXPR:
4782 : case UNLE_EXPR:
4783 : case UNGT_EXPR:
4784 : case UNGE_EXPR:
4785 : case UNEQ_EXPR:
4786 : case LTGT_EXPR:
4787 : case ORDERED_EXPR:
4788 : case UNORDERED_EXPR:
4789 : case LT_EXPR:
4790 : case LE_EXPR:
4791 : case GT_EXPR:
4792 : case GE_EXPR:
4793 : return 10;
4794 :
4795 : case LSHIFT_EXPR:
4796 : case RSHIFT_EXPR:
4797 : case LROTATE_EXPR:
4798 : case RROTATE_EXPR:
4799 : case VEC_WIDEN_LSHIFT_HI_EXPR:
4800 : case VEC_WIDEN_LSHIFT_LO_EXPR:
4801 : case WIDEN_LSHIFT_EXPR:
4802 : return 11;
4803 :
4804 : case WIDEN_SUM_EXPR:
4805 : case PLUS_EXPR:
4806 : case POINTER_PLUS_EXPR:
4807 : case POINTER_DIFF_EXPR:
4808 : case MINUS_EXPR:
4809 : return 12;
4810 :
4811 : case VEC_WIDEN_MULT_HI_EXPR:
4812 : case VEC_WIDEN_MULT_LO_EXPR:
4813 : case WIDEN_MULT_EXPR:
4814 : case DOT_PROD_EXPR:
4815 : case WIDEN_MULT_PLUS_EXPR:
4816 : case WIDEN_MULT_MINUS_EXPR:
4817 : case MULT_EXPR:
4818 : case MULT_HIGHPART_EXPR:
4819 : case TRUNC_DIV_EXPR:
4820 : case CEIL_DIV_EXPR:
4821 : case FLOOR_DIV_EXPR:
4822 : case ROUND_DIV_EXPR:
4823 : case RDIV_EXPR:
4824 : case EXACT_DIV_EXPR:
4825 : case TRUNC_MOD_EXPR:
4826 : case CEIL_MOD_EXPR:
4827 : case FLOOR_MOD_EXPR:
4828 : case ROUND_MOD_EXPR:
4829 : return 13;
4830 :
4831 : case TRUTH_NOT_EXPR:
4832 : case BIT_NOT_EXPR:
4833 : case POSTINCREMENT_EXPR:
4834 : case POSTDECREMENT_EXPR:
4835 : case PREINCREMENT_EXPR:
4836 : case PREDECREMENT_EXPR:
4837 : case NEGATE_EXPR:
4838 : case INDIRECT_REF:
4839 : case ADDR_EXPR:
4840 : case FLOAT_EXPR:
4841 : CASE_CONVERT:
4842 : case FIX_TRUNC_EXPR:
4843 : case TARGET_EXPR:
4844 : return 14;
4845 :
4846 : case CALL_EXPR:
4847 : case ARRAY_REF:
4848 : case ARRAY_RANGE_REF:
4849 : case COMPONENT_REF:
4850 : return 15;
4851 :
4852 : /* Special expressions. */
4853 : case MIN_EXPR:
4854 : case MAX_EXPR:
4855 : case ABS_EXPR:
4856 : case REALPART_EXPR:
4857 : case IMAGPART_EXPR:
4858 : case VEC_UNPACK_HI_EXPR:
4859 : case VEC_UNPACK_LO_EXPR:
4860 : case VEC_UNPACK_FLOAT_HI_EXPR:
4861 : case VEC_UNPACK_FLOAT_LO_EXPR:
4862 : case VEC_UNPACK_FIX_TRUNC_HI_EXPR:
4863 : case VEC_UNPACK_FIX_TRUNC_LO_EXPR:
4864 : case VEC_PACK_TRUNC_EXPR:
4865 : case VEC_PACK_SAT_EXPR:
4866 : return 16;
4867 :
4868 : default:
4869 : /* Return an arbitrarily high precedence to avoid surrounding single
4870 : VAR_DECLs in ()s. */
4871 : return 9999;
4872 : }
4873 : }
4874 :
4875 : /* Return the priority of the operator OP. */
4876 :
4877 : int
4878 17303486 : op_prio (const_tree op)
4879 : {
4880 17319689 : enum tree_code code;
4881 :
4882 17319689 : if (op == NULL)
4883 : return 9999;
4884 :
4885 17319467 : code = TREE_CODE (op);
4886 17319467 : if (code == SAVE_EXPR || code == NON_LVALUE_EXPR)
4887 16203 : return op_prio (TREE_OPERAND (op, 0));
4888 :
4889 17303264 : return op_code_prio (code);
4890 : }
4891 :
4892 : /* Return the symbol associated with operator CODE. */
4893 :
4894 : const char *
4895 2684605 : op_symbol_code (enum tree_code code, dump_flags_t flags)
4896 : {
4897 2684605 : switch (code)
4898 : {
4899 : case MODIFY_EXPR:
4900 : return "=";
4901 :
4902 2495 : case TRUTH_OR_EXPR:
4903 2495 : case TRUTH_ORIF_EXPR:
4904 2495 : return "||";
4905 :
4906 2781 : case TRUTH_AND_EXPR:
4907 2781 : case TRUTH_ANDIF_EXPR:
4908 2781 : return "&&";
4909 :
4910 35171 : case BIT_IOR_EXPR:
4911 35171 : return "|";
4912 :
4913 21935 : case TRUTH_XOR_EXPR:
4914 21935 : case BIT_XOR_EXPR:
4915 21935 : return "^";
4916 :
4917 375835 : case ADDR_EXPR:
4918 375835 : case BIT_AND_EXPR:
4919 375835 : return "&";
4920 :
4921 42 : case ORDERED_EXPR:
4922 42 : return (flags & TDF_GIMPLE) ? "__ORDERED" : "ord";
4923 62 : case UNORDERED_EXPR:
4924 62 : return (flags & TDF_GIMPLE) ? "__UNORDERED" : "unord";
4925 :
4926 64213 : case EQ_EXPR:
4927 64213 : return "==";
4928 17 : case UNEQ_EXPR:
4929 17 : return (flags & TDF_GIMPLE) ? "__UNEQ" : "u==";
4930 :
4931 191251 : case NE_EXPR:
4932 191251 : return "!=";
4933 :
4934 70376 : case LT_EXPR:
4935 70376 : return "<";
4936 91 : case UNLT_EXPR:
4937 91 : return (flags & TDF_GIMPLE) ? "__UNLT" : "u<";
4938 :
4939 30443 : case LE_EXPR:
4940 30443 : return "<=";
4941 125 : case UNLE_EXPR:
4942 125 : return (flags & TDF_GIMPLE) ? "__UNLE" : "u<=";
4943 :
4944 53303 : case GT_EXPR:
4945 53303 : return ">";
4946 134 : case UNGT_EXPR:
4947 134 : return (flags & TDF_GIMPLE) ? "__UNGT" : "u>";
4948 :
4949 9898 : case GE_EXPR:
4950 9898 : return ">=";
4951 78 : case UNGE_EXPR:
4952 78 : return (flags & TDF_GIMPLE) ? "__UNGE" : "u>=";
4953 :
4954 31 : case LTGT_EXPR:
4955 31 : return (flags & TDF_GIMPLE) ? "__LTGT" : "<>";
4956 :
4957 40556 : case LSHIFT_EXPR:
4958 40556 : return "<<";
4959 :
4960 90227 : case RSHIFT_EXPR:
4961 90227 : return ">>";
4962 :
4963 785 : case LROTATE_EXPR:
4964 785 : return (flags & TDF_GIMPLE) ? "__ROTATE_LEFT" : "r<<";
4965 :
4966 1381 : case RROTATE_EXPR:
4967 1381 : return (flags & TDF_GIMPLE) ? "__ROTATE_RIGHT" : "r>>";
4968 :
4969 0 : case WIDEN_LSHIFT_EXPR:
4970 0 : return "w<<";
4971 :
4972 : case POINTER_PLUS_EXPR:
4973 : return "+";
4974 :
4975 : case PLUS_EXPR:
4976 : return "+";
4977 :
4978 0 : case WIDEN_SUM_EXPR:
4979 0 : return "w+";
4980 :
4981 10105 : case WIDEN_MULT_EXPR:
4982 10105 : return "w*";
4983 :
4984 7134 : case MULT_HIGHPART_EXPR:
4985 7134 : return (flags & TDF_GIMPLE) ? "__MULT_HIGHPART" : "h*";
4986 :
4987 188894 : case NEGATE_EXPR:
4988 188894 : case MINUS_EXPR:
4989 188894 : case POINTER_DIFF_EXPR:
4990 188894 : return "-";
4991 :
4992 714 : case BIT_NOT_EXPR:
4993 714 : return "~";
4994 :
4995 491 : case TRUTH_NOT_EXPR:
4996 491 : return "!";
4997 :
4998 364558 : case MULT_EXPR:
4999 364558 : case INDIRECT_REF:
5000 364558 : return "*";
5001 :
5002 14026 : case TRUNC_DIV_EXPR:
5003 14026 : case RDIV_EXPR:
5004 14026 : return "/";
5005 :
5006 135 : case CEIL_DIV_EXPR:
5007 135 : return "/[cl]";
5008 :
5009 217 : case FLOOR_DIV_EXPR:
5010 217 : return "/[fl]";
5011 :
5012 126 : case ROUND_DIV_EXPR:
5013 126 : return "/[rd]";
5014 :
5015 447 : case EXACT_DIV_EXPR:
5016 447 : return "/[ex]";
5017 :
5018 6931 : case TRUNC_MOD_EXPR:
5019 6931 : return "%";
5020 :
5021 126 : case CEIL_MOD_EXPR:
5022 126 : return "%[cl]";
5023 :
5024 63 : case FLOOR_MOD_EXPR:
5025 63 : return "%[fl]";
5026 :
5027 126 : case ROUND_MOD_EXPR:
5028 126 : return "%[rd]";
5029 :
5030 53 : case PREDECREMENT_EXPR:
5031 53 : return " --";
5032 :
5033 538 : case PREINCREMENT_EXPR:
5034 538 : return " ++";
5035 :
5036 10 : case POSTDECREMENT_EXPR:
5037 10 : return "-- ";
5038 :
5039 1513 : case POSTINCREMENT_EXPR:
5040 1513 : return "++ ";
5041 :
5042 24 : case MAX_EXPR:
5043 24 : return "max";
5044 :
5045 22 : case MIN_EXPR:
5046 22 : return "min";
5047 :
5048 1422 : default:
5049 1422 : return "<<< ??? >>>";
5050 : }
5051 : }
5052 :
5053 : /* Return the symbol associated with operator OP. */
5054 :
5055 : static const char *
5056 590821 : op_symbol (const_tree op, dump_flags_t flags)
5057 : {
5058 590821 : return op_symbol_code (TREE_CODE (op), flags);
5059 : }
5060 :
5061 : /* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or
5062 : the gimple_call_fn of a GIMPLE_CALL. */
5063 :
5064 : void
5065 184617 : print_call_name (pretty_printer *pp, tree node, dump_flags_t flags)
5066 : {
5067 184617 : tree op0 = node;
5068 184617 : int spc = 0;
5069 :
5070 184617 : if (TREE_CODE (op0) == NON_LVALUE_EXPR)
5071 4 : op0 = TREE_OPERAND (op0, 0);
5072 :
5073 184617 : again:
5074 364866 : switch (TREE_CODE (op0))
5075 : {
5076 179161 : case VAR_DECL:
5077 179161 : case PARM_DECL:
5078 179161 : case FUNCTION_DECL:
5079 179161 : dump_function_name (pp, op0, flags);
5080 179161 : break;
5081 :
5082 180249 : case ADDR_EXPR:
5083 180249 : case INDIRECT_REF:
5084 180249 : CASE_CONVERT:
5085 180249 : op0 = TREE_OPERAND (op0, 0);
5086 180249 : goto again;
5087 :
5088 0 : case COND_EXPR:
5089 0 : pp_left_paren (pp);
5090 0 : dump_generic_node (pp, TREE_OPERAND (op0, 0), 0, flags, false);
5091 0 : pp_string (pp, ") ? ");
5092 0 : dump_generic_node (pp, TREE_OPERAND (op0, 1), 0, flags, false);
5093 0 : pp_string (pp, " : ");
5094 0 : dump_generic_node (pp, TREE_OPERAND (op0, 2), 0, flags, false);
5095 0 : break;
5096 :
5097 0 : case ARRAY_REF:
5098 0 : if (VAR_P (TREE_OPERAND (op0, 0)))
5099 0 : dump_function_name (pp, TREE_OPERAND (op0, 0), flags);
5100 : else
5101 0 : dump_generic_node (pp, op0, 0, flags, false);
5102 : break;
5103 :
5104 0 : case MEM_REF:
5105 0 : if (integer_zerop (TREE_OPERAND (op0, 1)))
5106 : {
5107 0 : op0 = TREE_OPERAND (op0, 0);
5108 0 : goto again;
5109 : }
5110 : /* Fallthru. */
5111 5456 : case COMPONENT_REF:
5112 5456 : case SSA_NAME:
5113 5456 : case OBJ_TYPE_REF:
5114 5456 : dump_generic_node (pp, op0, 0, flags, false);
5115 5456 : break;
5116 :
5117 0 : default:
5118 0 : NIY;
5119 : }
5120 184617 : }
5121 :
5122 : /* Print the first N characters in the array STR, replacing non-printable
5123 : characters (including embedded nuls) with unambiguous escape sequences. */
5124 :
5125 : void
5126 61379 : pretty_print_string (pretty_printer *pp, const char *str, size_t n)
5127 : {
5128 61379 : if (str == NULL)
5129 : return;
5130 :
5131 1467914 : for ( ; n; --n, ++str)
5132 : {
5133 1406535 : switch (str[0])
5134 : {
5135 26 : case '\b':
5136 26 : pp_string (pp, "\\b");
5137 26 : break;
5138 :
5139 30 : case '\f':
5140 30 : pp_string (pp, "\\f");
5141 30 : break;
5142 :
5143 2942 : case '\n':
5144 2942 : pp_string (pp, "\\n");
5145 2942 : break;
5146 :
5147 18 : case '\r':
5148 18 : pp_string (pp, "\\r");
5149 18 : break;
5150 :
5151 44 : case '\t':
5152 44 : pp_string (pp, "\\t");
5153 44 : break;
5154 :
5155 20 : case '\v':
5156 20 : pp_string (pp, "\\v");
5157 20 : break;
5158 :
5159 51 : case '\\':
5160 51 : pp_string (pp, "\\\\");
5161 51 : break;
5162 :
5163 146 : case '\"':
5164 146 : pp_string (pp, "\\\"");
5165 146 : break;
5166 :
5167 14827 : case '\'':
5168 14827 : pp_string (pp, "\\'");
5169 14827 : break;
5170 :
5171 1388431 : default:
5172 1388431 : if (str[0] || n > 1)
5173 : {
5174 1348113 : if (!ISPRINT (str[0]))
5175 : {
5176 6835 : char buf[5];
5177 6835 : sprintf (buf, "\\x%02x", (unsigned char)str[0]);
5178 6835 : pp_string (pp, buf);
5179 : }
5180 : else
5181 1341278 : pp_character (pp, str[0]);
5182 : break;
5183 : }
5184 : }
5185 : }
5186 : }
5187 :
5188 : static void
5189 6119571 : maybe_init_pretty_print (FILE *file)
5190 : {
5191 6119571 : if (!tree_pp)
5192 : {
5193 18578 : tree_pp = new pretty_printer ();
5194 18578 : pp_needs_newline (tree_pp) = true;
5195 18578 : pp_translate_identifiers (tree_pp) = false;
5196 : }
5197 :
5198 6119571 : tree_pp->set_output_stream (file);
5199 6119571 : }
5200 :
5201 : static void
5202 570855 : newline_and_indent (pretty_printer *pp, int spc)
5203 : {
5204 570855 : pp_newline (pp);
5205 7022218 : INDENT (spc);
5206 570855 : }
5207 :
5208 : /* Print the identifier ID to PRETTY-PRINTER. */
5209 :
5210 : void
5211 15215982 : pp_tree_identifier (pretty_printer *pp, tree id)
5212 : {
5213 15215982 : if (pp_translate_identifiers (pp))
5214 : {
5215 8642839 : const char *text = identifier_to_locale (IDENTIFIER_POINTER (id));
5216 8642839 : pp_append_text (pp, text, text + strlen (text));
5217 : }
5218 : else
5219 6573143 : pp_append_text (pp, IDENTIFIER_POINTER (id),
5220 6573143 : IDENTIFIER_POINTER (id) + IDENTIFIER_LENGTH (id));
5221 15215982 : }
5222 :
5223 : /* A helper function that is used to dump function information before the
5224 : function dump. */
5225 :
5226 : void
5227 60361 : dump_function_header (FILE *dump_file, tree fdecl, dump_flags_t flags)
5228 : {
5229 60361 : const char *dname, *aname;
5230 60361 : struct cgraph_node *node = cgraph_node::get (fdecl);
5231 60361 : struct function *fun = DECL_STRUCT_FUNCTION (fdecl);
5232 :
5233 60361 : dname = lang_hooks.decl_printable_name (fdecl, 1);
5234 :
5235 60361 : if (DECL_ASSEMBLER_NAME_SET_P (fdecl))
5236 60357 : aname = (IDENTIFIER_POINTER
5237 : (DECL_ASSEMBLER_NAME (fdecl)));
5238 : else
5239 : aname = "<unset-asm-name>";
5240 :
5241 60361 : fprintf (dump_file, "\n;; Function %s (%s, funcdef_no=%d",
5242 : dname, aname, fun->funcdef_no);
5243 60361 : if (!(flags & TDF_NOUID))
5244 56388 : fprintf (dump_file, ", decl_uid=%d", DECL_UID (fdecl));
5245 60361 : if (node)
5246 : {
5247 60361 : fprintf (dump_file, ", cgraph_uid=%d", node->get_uid ());
5248 60361 : fprintf (dump_file, ", symbol_order=%d)%s\n\n", node->order,
5249 60361 : node->frequency == NODE_FREQUENCY_HOT
5250 : ? " (hot)"
5251 : : node->frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED
5252 60274 : ? " (unlikely executed)"
5253 : : node->frequency == NODE_FREQUENCY_EXECUTED_ONCE
5254 59974 : ? " (executed once)"
5255 : : "");
5256 : }
5257 : else
5258 0 : fprintf (dump_file, ")\n\n");
5259 60361 : }
5260 :
5261 : /* Dump double_int D to pretty_printer PP. UNS is true
5262 : if D is unsigned and false otherwise. */
5263 : void
5264 0 : pp_double_int (pretty_printer *pp, double_int d, bool uns)
5265 : {
5266 0 : if (d.fits_shwi ())
5267 0 : pp_wide_integer (pp, d.low);
5268 0 : else if (d.fits_uhwi ())
5269 0 : pp_unsigned_wide_integer (pp, d.low);
5270 : else
5271 : {
5272 0 : unsigned HOST_WIDE_INT low = d.low;
5273 0 : HOST_WIDE_INT high = d.high;
5274 0 : if (!uns && d.is_negative ())
5275 : {
5276 0 : pp_minus (pp);
5277 0 : high = ~high + !low;
5278 0 : low = -low;
5279 : }
5280 : /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
5281 : systems? */
5282 0 : sprintf (pp_buffer (pp)->m_digit_buffer,
5283 : HOST_WIDE_INT_PRINT_DOUBLE_HEX,
5284 : (unsigned HOST_WIDE_INT) high, low);
5285 0 : pp_string (pp, pp_buffer (pp)->m_digit_buffer);
5286 : }
5287 0 : }
5288 :
5289 : #if __GNUC__ >= 10
5290 : # pragma GCC diagnostic pop
5291 : #endif
|
