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