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